图 7-12 完美二叉树的数组表示
-**映射公式的角色相当于链表中的引用**。给定数组中的任意一个节点，我们都可以通过映射公式来访问它的左（右）子节点。 +**映射公式的角色相当于链表中的节点引用（指针）**。给定数组中的任意一个节点，我们都可以通过映射公式来访问它的左（右）子节点。 ## 7.3.2 表示任意二叉树 diff --git a/en/docs/chapter_graph/graph.md b/en/docs/chapter_graph/graph.md new file mode 100644 index 000000000..bfd0de110 --- /dev/null +++ b/en/docs/chapter_graph/graph.md @@ -0,0 +1,103 @@ +--- +comments: true +--- + +# 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**. + +{ class="animation-figure" } + +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. + +{ class="animation-figure" } + +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. + +{ class="animation-figure" } + +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. + +{ class="animation-figure" } + +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. + +{ class="animation-figure" } + +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. + +{ class="animation-figure" } + +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
+ +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: + +=== "Python" + + ```python title="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) + ``` + +=== "C++" + + ```cpp title="graph_adjacency_matrix.cpp" + /* 基于邻接矩阵实现的无向图类 */ + class GraphAdjMat { + vectorFigure 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. + +=== "Python" + + ```python title="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},") + ``` + +=== "C++" + + ```cpp title="graph_adjacency_list.cpp" + /* 基于邻接表实现的无向图类 */ + class GraphAdjList { + public: + // 邻接表，key：顶点，value：该顶点的所有邻接顶点 + unordered_mapTable 9-2 Comparison of adjacency matrix and adjacency list
+ +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. 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. + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="graph_bfs.cpp" + /* 广度优先遍历 */ + // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点 + vectorFigure 9-10 Steps of breadth-first search of a graph
+ +!!! question "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. + +## 9.3.2 Depth-first search + +**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. + +{ class="animation-figure" } + +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. + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="graph_dfs.cpp" + /* 深度优先遍历辅助函数 */ + void dfs(GraphAdjList &graph, unordered_setFigure 9-12 Steps of depth-first search of a graph
+ +!!! question "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. diff --git a/en/docs/chapter_graph/index.md b/en/docs/chapter_graph/index.md new file mode 100644 index 000000000..095d4b309 --- /dev/null +++ b/en/docs/chapter_graph/index.md @@ -0,0 +1,21 @@ +--- +comments: true +icon: material/graphql +--- + +# Chapter 9. Graph + +{ class="cover-image" } + +!!! 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 + +- [9.1 Graph](https://www.hello-algo.com/en/chapter_graph/graph/) +- [9.2 Basic Graph Operations](https://www.hello-algo.com/en/chapter_graph/graph_operations/) +- [9.3 Graph Traversal](https://www.hello-algo.com/en/chapter_graph/graph_traversal/) +- [9.4 Summary](https://www.hello-algo.com/en/chapter_graph/summary/) diff --git a/en/docs/chapter_graph/summary.md b/en/docs/chapter_graph/summary.md new file mode 100644 index 000000000..65af81c80 --- /dev/null +++ b/en/docs/chapter_graph/summary.md @@ -0,0 +1,35 @@ +--- +comments: true +--- + +# 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. diff --git a/en/docs/chapter_heap/build_heap.md b/en/docs/chapter_heap/build_heap.md new file mode 100644 index 000000000..60edf2a5e --- /dev/null +++ b/en/docs/chapter_heap/build_heap.md @@ -0,0 +1,382 @@ +--- +comments: true +--- + +# 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. 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: + +=== "Python" + + ```python title="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) + ``` + +=== "C++" + + ```cpp title="my_heap.cpp" + /* 构造方法，根据输入列表建堆 */ + MaxHeap(vectorFigure 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**. diff --git a/en/docs/chapter_heap/heap.md b/en/docs/chapter_heap/heap.md new file mode 100644 index 000000000..658b3817d --- /dev/null +++ b/en/docs/chapter_heap/heap.md @@ -0,0 +1,1820 @@ +--- +comments: true +--- + +# 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. + +{ class="animation-figure" } + +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
+ +Figure 8-2 Representation and storage of heaps
+ +We can encapsulate the index mapping formula into functions for convenient later use: + +=== "Python" + + ```python title="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 # 向下整除 + ``` + +=== "C++" + + ```cpp title="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; // 向下整除 + } + ``` + +=== "Java" + + ```java title="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; // 向下整除 + } + ``` + +=== "C#" + + ```csharp title="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; // 向下整除 + } + ``` + +=== "Go" + + ```go title="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 + } + ``` + +=== "Swift" + + ```swift title="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 // 向下整除 + } + ``` + +=== "JS" + + ```javascript title="my_heap.js" + /* 获取左子节点的索引 */ + #left(i) { + return 2 * i + 1; + } + + /* 获取右子节点的索引 */ + #right(i) { + return 2 * i + 2; + } + + /* 获取父节点的索引 */ + #parent(i) { + return Math.floor((i - 1) / 2); // 向下整除 + } + ``` + +=== "TS" + + ```typescript title="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); // 向下整除 + } + ``` + +=== "Dart" + + ```dart title="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; // 向下整除 + } + ``` + +=== "Rust" + + ```rust title="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 // 向下整除 + } + ``` + +=== "C" + + ```c title="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; + } + ``` + +=== "Kotlin" + + ```kotlin title="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 // 向下整除 + } + ``` + +=== "Ruby" + + ```ruby title="my_heap.rb" + [class]{MaxHeap}-[func]{left} + + [class]{MaxHeap}-[func]{right} + + [class]{MaxHeap}-[func]{parent} + ``` + +=== "Zig" + + ```zig title="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: + +=== "Python" + + ```python title="my_heap.py" + def peek(self) -> int: + """访问堆顶元素""" + return self.max_heap[0] + ``` + +=== "C++" + + ```cpp title="my_heap.cpp" + /* 访问堆顶元素 */ + int peek() { + return maxHeap[0]; + } + ``` + +=== "Java" + + ```java title="my_heap.java" + /* 访问堆顶元素 */ + int peek() { + return maxHeap.get(0); + } + ``` + +=== "C#" + + ```csharp title="my_heap.cs" + /* 访问堆顶元素 */ + int Peek() { + return maxHeap[0]; + } + ``` + +=== "Go" + + ```go title="my_heap.go" + /* 访问堆顶元素 */ + func (h *maxHeap) peek() any { + return h.data[0] + } + ``` + +=== "Swift" + + ```swift title="my_heap.swift" + /* 访问堆顶元素 */ + func peek() -> Int { + maxHeap[0] + } + ``` + +=== "JS" + + ```javascript title="my_heap.js" + /* 访问堆顶元素 */ + peek() { + return this.#maxHeap[0]; + } + ``` + +=== "TS" + + ```typescript title="my_heap.ts" + /* 访问堆顶元素 */ + peek(): number { + return this.maxHeap[0]; + } + ``` + +=== "Dart" + + ```dart title="my_heap.dart" + /* 访问堆顶元素 */ + int peek() { + return _maxHeap[0]; + } + ``` + +=== "Rust" + + ```rust title="my_heap.rs" + /* 访问堆顶元素 */ + fn peek(&self) -> OptionFigure 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: + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="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; + } + } + ``` + +=== "Java" + + ```java title="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; + } + } + ``` + +=== "C#" + + ```csharp title="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; + } + } + ``` + +=== "Go" + + ```go title="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 + } + } + ``` + +=== "Swift" + + ```swift title="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 + } + } + ``` + +=== "JS" + + ```javascript title="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; + } + } + ``` + +=== "TS" + + ```typescript title="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; + } + } + ``` + +=== "Dart" + + ```dart title="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; + } + } + ``` + +=== "Rust" + + ```rust title="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; + } + } + ``` + +=== "C" + + ```c title="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; + } + } + ``` + +=== "Kotlin" + + ```kotlin title="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 + } + } + ``` + +=== "Ruby" + + ```ruby title="my_heap.rb" + [class]{MaxHeap}-[func]{push} + + [class]{MaxHeap}-[func]{sift_up} + ``` + +=== "Zig" + + ```zig title="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; + } + } + ``` + +??? pythontutor "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. 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>" + { class="animation-figure" } + +=== "<2>" + { class="animation-figure" } + +=== "<3>" + { class="animation-figure" } + +=== "<4>" + { class="animation-figure" } + +=== "<5>" + { class="animation-figure" } + +=== "<6>" + { class="animation-figure" } + +=== "<7>" + { class="animation-figure" } + +=== "<8>" + { class="animation-figure" } + +=== "<9>" + { class="animation-figure" } + +=== "<10>" + { class="animation-figure" } + +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: + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="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; + } + } + ``` + +=== "Java" + + ```java title="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; + } + } + ``` + +=== "C#" + + ```csharp title="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; + } + } + ``` + +=== "Go" + + ```go title="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 + } + } + ``` + +=== "Swift" + + ```swift title="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 + } + } + ``` + +=== "JS" + + ```javascript title="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; + } + } + ``` + +=== "TS" + + ```typescript title="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; + } + } + ``` + +=== "Dart" + + ```dart title="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; + } + } + ``` + +=== "Rust" + + ```rust title="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; + } + } + ``` + +=== "C" + + ```c title="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; + } + } + ``` + +=== "Kotlin" + + ```kotlin title="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 + } + } + ``` + +=== "Ruby" + + ```ruby title="my_heap.rb" + [class]{MaxHeap}-[func]{pop} + + [class]{MaxHeap}-[func]{sift_down} + ``` + +=== "Zig" + + ```zig title="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; + } + } + ``` + +??? pythontutor "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. diff --git a/en/docs/chapter_heap/index.md b/en/docs/chapter_heap/index.md new file mode 100644 index 000000000..55c022d03 --- /dev/null +++ b/en/docs/chapter_heap/index.md @@ -0,0 +1,21 @@ +--- +comments: true +icon: material/family-tree +--- + +# Chapter 8. Heap + +{ class="cover-image" } + +!!! 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 + +- [8.1 Heap](https://www.hello-algo.com/en/chapter_heap/heap/) +- [8.2 Building a Heap](https://www.hello-algo.com/en/chapter_heap/build_heap/) +- [8.3 Top-k Problem](https://www.hello-algo.com/en/chapter_heap/top_k/) +- [8.4 Summary](https://www.hello-algo.com/en/chapter_heap/summary/) diff --git a/en/docs/chapter_heap/summary.md b/en/docs/chapter_heap/summary.md new file mode 100644 index 000000000..9d4e4c991 --- /dev/null +++ b/en/docs/chapter_heap/summary.md @@ -0,0 +1,21 @@ +--- +comments: true +--- + +# 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. diff --git a/en/docs/chapter_heap/top_k.md b/en/docs/chapter_heap/top_k.md new file mode 100644 index 000000000..ec5ca84e7 --- /dev/null +++ b/en/docs/chapter_heap/top_k.md @@ -0,0 +1,456 @@ +--- +comments: true +--- + +# 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. + +{ class="animation-figure" } + +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. + +{ class="animation-figure" } + +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. 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>" + { class="animation-figure" } + +=== "<2>" + { class="animation-figure" } + +=== "<3>" + { class="animation-figure" } + +=== "<4>" + { class="animation-figure" } + +=== "<5>" + { class="animation-figure" } + +=== "<6>" + { class="animation-figure" } + +=== "<7>" + { class="animation-figure" } + +=== "<8>" + { class="animation-figure" } + +=== "<9>" + { class="animation-figure" } + +Figure 8-8 Find the largest k elements based on heap
+ +Example code is as follows: + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="top_k.cpp" + /* 基于堆查找数组中最大的 k 个元素 */ + priority_queueFigure 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. + +{ class="animation-figure" } + +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: + +=== "Python" + + ```python title="" + # 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] + ``` + +=== "C++" + + ```cpp title="" + /* Array representation of a binary tree */ + // Using the maximum integer value INT_MAX to mark empty slots + vectorFigure 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. + +{ class="animation-figure" } + +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. + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="array_binary_tree.cpp" + /* 数组表示下的二叉树类 */ + class ArrayBinaryTree { + public: + /* 构造方法 */ + ArrayBinaryTree(vectorFigure 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. + +{ class="animation-figure" } + +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: + +=== "Python" + + ```python title="" + 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 + ``` + +=== "C++" + + ```cpp title="" + /* 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){} + }; + ``` + +=== "Java" + + ```java title="" + /* 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; } + } + ``` + +=== "C#" + + ```csharp title="" + /* 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 + } + ``` + +=== "Go" + + ```go title="" + /* AVL tree node */ + type TreeNode struct { + Val int // Node value + Height int // Node height + Left *TreeNode // Left child reference + Right *TreeNode // Right child reference + } + ``` + +=== "Swift" + + ```swift title="" + /* 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 + } + } + ``` + +=== "JS" + + ```javascript title="" + /* 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; + } + } + ``` + +=== "TS" + + ```typescript title="" + /* 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; + } + } + ``` + +=== "Dart" + + ```dart title="" + /* 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]); + } + ``` + +=== "Rust" + + ```rust title="" + use std::rc::Rc; + use std::cell::RefCell; + + /* AVL tree node */ + struct TreeNode { + val: i32, // Node value + height: i32, // Node height + left: OptionFigure 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`. + +{ class="animation-figure" } + +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: + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="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; + } + ``` + +=== "Java" + + ```java title="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; + } + ``` + +=== "C#" + + ```csharp title="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; + } + ``` + +=== "Go" + + ```go title="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 + } + ``` + +=== "Swift" + + ```swift title="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 + } + ``` + +=== "JS" + + ```javascript title="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; + } + ``` + +=== "TS" + + ```typescript title="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; + } + ``` + +=== "Dart" + + ```dart title="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; + } + ``` + +=== "Rust" + + ```rust title="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, + } + } + ``` + +=== "C" + + ```c title="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; + } + ``` + +=== "Kotlin" + + ```kotlin title="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 + } + ``` + +=== "Ruby" + + ```ruby title="avl_tree.rb" + [class]{AVLTree}-[func]{right_rotate} + ``` + +=== "Zig" + + ```zig title="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. + +{ class="animation-figure" } + +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`. + +{ class="animation-figure" } + +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: + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="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; + } + ``` + +=== "Java" + + ```java title="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; + } + ``` + +=== "C#" + + ```csharp title="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; + } + ``` + +=== "Go" + + ```go title="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 + } + ``` + +=== "Swift" + + ```swift title="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 + } + ``` + +=== "JS" + + ```javascript title="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; + } + ``` + +=== "TS" + + ```typescript title="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; + } + ``` + +=== "Dart" + + ```dart title="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; + } + ``` + +=== "Rust" + + ```rust title="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, + } + } + ``` + +=== "C" + + ```c title="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; + } + ``` + +=== "Kotlin" + + ```kotlin title="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 + } + ``` + +=== "Ruby" + + ```ruby title="avl_tree.rb" + [class]{AVLTree}-[func]{left_rotate} + ``` + +=== "Zig" + + ```zig title="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`. + +{ class="animation-figure" } + +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`. + +{ class="animation-figure" } + +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. + +{ class="animation-figure" } + +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
+ +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. + +=== "<1>" + { class="animation-figure" } + +=== "<2>" + { class="animation-figure" } + +=== "<3>" + { class="animation-figure" } + +=== "<4>" + { class="animation-figure" } + +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: + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="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; + } + ``` + +=== "Java" + + ```java title="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; + } + ``` + +=== "C#" + + ```csharp title="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; + } + ``` + +=== "Go" + + ```go title="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 + } + ``` + +=== "Swift" + + ```swift title="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 + } + ``` + +=== "JS" + + ```javascript title="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; + } + ``` + +=== "TS" + + ```typescript title="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; + } + ``` + +=== "Dart" + + ```dart title="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; + } + ``` + +=== "Rust" + + ```rust title="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 + } + ``` + +=== "C" + + ```c title="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; + } + ``` + +=== "Kotlin" + + ```kotlin title="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 + } + ``` + +=== "Ruby" + + ```ruby title="binary_search_tree.rb" + [class]{BinarySearchTree}-[func]{search} + ``` + +=== "Zig" + + ```zig title="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; + } + ``` + +??? pythontutor "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. **Insert the node at that position**: Initialize the node `num` and place it where `None` was. + +{ class="animation-figure" } + +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. + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="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; + } + ``` + +=== "Java" + + ```java title="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; + } + ``` + +=== "C#" + + ```csharp title="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; + } + } + ``` + +=== "Go" + + ```go title="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 + } + } + ``` + +=== "Swift" + + ```swift title="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 + } + } + ``` + +=== "JS" + + ```javascript title="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; + } + ``` + +=== "TS" + + ```typescript title="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; + } + ``` + +=== "Dart" + + ```dart title="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; + } + ``` + +=== "Rust" + + ```rust title="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; + } + } + ``` + +=== "C" + + ```c title="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; + } + } + ``` + +=== "Kotlin" + + ```kotlin title="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 + } + ``` + +=== "Ruby" + + ```ruby title="binary_search_tree.rb" + [class]{BinarySearchTree}-[func]{insert} + ``` + +=== "Zig" + + ```zig title="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; + } + } + ``` + +??? pythontutor "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. + +{ class="animation-figure" } + +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. + +{ class="animation-figure" } + +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. Replace the value of the node to be removed with `tmp`'s value, and recursively remove the node `tmp` in the tree. + +=== "<1>" + { class="animation-figure" } + +=== "<2>" + { class="animation-figure" } + +=== "<3>" + { class="animation-figure" } + +=== "<4>" + { class="animation-figure" } + +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: + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="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; + } + } + ``` + +=== "Java" + + ```java title="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; + } + } + ``` + +=== "C#" + + ```csharp title="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; + } + } + ``` + +=== "Go" + + ```go title="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 + } + } + ``` + +=== "Swift" + + ```swift title="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 + } + } + ``` + +=== "JS" + + ```javascript title="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; + } + } + ``` + +=== "TS" + + ```typescript title="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; + } + } + ``` + +=== "Dart" + + ```dart title="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; + } + } + ``` + +=== "Rust" + + ```rust title="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; + } + } + } + ``` + +=== "C" + + ```c title="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; + } + } + ``` + +=== "Kotlin" + + ```kotlin title="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 + } + } + ``` + +=== "Ruby" + + ```ruby title="binary_search_tree.rb" + [class]{BinarySearchTree}-[func]{remove} + ``` + +=== "Zig" + + ```zig title="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; + } + } + ``` + +??? pythontutor "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. + +{ class="animation-figure" } + +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
+ +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. diff --git a/en/docs/chapter_tree/binary_tree.md b/en/docs/chapter_tree/binary_tree.md new file mode 100644 index 000000000..02abb2d45 --- /dev/null +++ b/en/docs/chapter_tree/binary_tree.md @@ -0,0 +1,686 @@ +--- +comments: true +--- + +# 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. + +=== "Python" + + ```python title="" + 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 + ``` + +=== "C++" + + ```cpp title="" + /* 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) {} + }; + ``` + +=== "Java" + + ```java title="" + /* 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; } + } + ``` + +=== "C#" + + ```csharp title="" + /* 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 + } + ``` + +=== "Go" + + ```go title="" + /* 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 + } + } + ``` + +=== "Swift" + + ```swift title="" + /* 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 + } + } + ``` + +=== "JS" + + ```javascript title="" + /* 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; + } + } + ``` + +=== "TS" + + ```typescript title="" + /* 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 + } + } + ``` + +=== "Dart" + + ```dart title="" + /* 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]); + } + ``` + +=== "Rust" + + ```rust title="" + use std::rc::Rc; + use std::cell::RefCell; + + /* Binary tree node */ + struct TreeNode { + val: i32, // Node value + left: OptionFigure 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. + +{ class="animation-figure" } + +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). + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="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; + ``` + +=== "Java" + + ```java title="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; + ``` + +=== "C#" + + ```csharp title="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; + ``` + +=== "Go" + + ```go title="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 + ``` + +=== "Swift" + + ```swift title="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 + ``` + +=== "JS" + + ```javascript title="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; + ``` + +=== "TS" + + ```typescript title="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; + ``` + +=== "Dart" + + ```dart title="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; + ``` + +=== "Rust" + + ```rust title="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); + ``` + +=== "C" + + ```c title="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; + ``` + +=== "Kotlin" + + ```kotlin title="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 + ``` + +=== "Ruby" + + ```ruby title="binary_tree.rb" + + ``` + +=== "Zig" + + ```zig title="binary_tree.zig" + + ``` + +??? pythontutor "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. + +{ class="animation-figure" } + +Figure 7-3 Inserting and removing nodes in a binary tree
+ +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="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; + ``` + +=== "Java" + + ```java title="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; + ``` + +=== "C#" + + ```csharp title="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; + ``` + +=== "Go" + + ```go title="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 + ``` + +=== "Swift" + + ```swift title="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 + ``` + +=== "JS" + + ```javascript title="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; + ``` + +=== "TS" + + ```typescript title="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; + ``` + +=== "Dart" + + ```dart title="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; + ``` + +=== "Rust" + + ```rust title="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); + ``` + +=== "C" + + ```c title="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; + ``` + +=== "Kotlin" + + ```kotlin title="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 + ``` + +=== "Ruby" + + ```ruby title="binary_tree.rb" + + ``` + +=== "Zig" + + ```zig title="binary_tree.zig" + + ``` + +??? pythontutor "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." + +{ class="animation-figure" } + +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. + +{ class="animation-figure" } + +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. + +{ class="animation-figure" } + +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. + +{ class="animation-figure" } + +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)$. + +{ class="animation-figure" } + +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
+ +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: + +=== "Python" + + ```python title="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 + ``` + +=== "C++" + + ```cpp title="binary_tree_bfs.cpp" + /* 层序遍历 */ + vectorFigure 7-10 Preorder, inorder, and postorder traversal of a binary search tree
+ +### 1. Code implementation + +Depth-first search is usually implemented based on recursion: + +=== "Python" + + ```python title="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) + ``` + +=== "C++" + + ```cpp title="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); + } + ``` + +=== "Java" + + ```java title="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); + } + ``` + +=== "C#" + + ```csharp title="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); + } + ``` + +=== "Go" + + ```go title="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) + } + ``` + +=== "Swift" + + ```swift title="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) + } + ``` + +=== "JS" + + ```javascript title="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); + } + ``` + +=== "TS" + + ```typescript title="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); + } + ``` + +=== "Dart" + + ```dart title="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); + } + ``` + +=== "Rust" + + ```rust title="binary_tree_dfs.rs" + /* 前序遍历 */ + fn pre_order(root: Option<&RcFigure 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. diff --git a/en/docs/chapter_tree/index.md b/en/docs/chapter_tree/index.md new file mode 100644 index 000000000..a5d1da56c --- /dev/null +++ b/en/docs/chapter_tree/index.md @@ -0,0 +1,23 @@ +--- +comments: true +icon: material/graph-outline +--- + +# Chapter 7. Tree + +{ class="cover-image" } + +!!! 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 + +- [7.1 Binary Tree](https://www.hello-algo.com/en/chapter_tree/binary_tree/) +- [7.2 Binary Tree Traversal](https://www.hello-algo.com/en/chapter_tree/binary_tree_traversal/) +- [7.3 Array Representation of Tree](https://www.hello-algo.com/en/chapter_tree/array_representation_of_tree/) +- [7.4 Binary Search Tree](https://www.hello-algo.com/en/chapter_tree/binary_search_tree/) +- [7.5 AVL Tree *](https://www.hello-algo.com/en/chapter_tree/avl_tree/) +- [7.6 Summary](https://www.hello-algo.com/en/chapter_tree/summary/) diff --git a/en/docs/chapter_tree/summary.md b/en/docs/chapter_tree/summary.md new file mode 100644 index 000000000..a7cd0a41a --- /dev/null +++ b/en/docs/chapter_tree/summary.md @@ -0,0 +1,58 @@ +--- +comments: true +--- + +# 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.