mirror of
https://github.com/krahets/hello-algo.git
synced 2026-06-30 17:44:26 +00:00
Yudong Jin
b01036b09e
* Update giscus scroller. * Refine English docs and landing page * Sync the headings. * Update landing pages. * Update the avatar * Update Acknowledgements * Update landing pages. * Update contributors. * Update * Fix the formula formatting. * Fix the glossary. * Chapter 6. Hashing * Remove Chinese chars. * Fix headings. * Update giscus themes. * fallback to default giscus theme to solve 429 many requests error. * Add borders for callouts. * docs: sync character encoding translations * Update landing page media layout and i18n
90 lines
4.1 KiB
Markdown
Executable File
90 lines
4.1 KiB
Markdown
Executable File
# Binary Tree Traversal
|
|
|
|
From a physical structure perspective, a tree is a data structure based on linked lists. Hence, its traversal method involves accessing nodes one by one through pointers. However, a tree is a non-linear data structure, which makes traversing a tree more complex than traversing a linked list, requiring the assistance of search algorithms.
|
|
|
|
The common traversal methods for binary trees include level-order traversal, pre-order traversal, in-order traversal, and post-order traversal.
|
|
|
|
## Level-Order Traversal
|
|
|
|
As shown in the figure below, <u>level-order traversal</u> traverses the binary tree from top to bottom, layer by layer. Within each level, it visits nodes from left to right.
|
|
|
|
Level-order traversal is essentially <u>breadth-first traversal</u>, also known as <u>breadth-first search (BFS)</u>, which proceeds outward level by level.
|
|
|
|
|
|
|
|
### Code Implementation
|
|
|
|
Breadth-first traversal is typically 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:
|
|
|
|
```src
|
|
[file]{binary_tree_bfs}-[class]{}-[func]{level_order}
|
|
```
|
|
|
|
### Complexity Analysis
|
|
|
|
- **Time complexity is $O(n)$**: All nodes are visited once, using $O(n)$ time, where $n$ is the number of nodes.
|
|
- **Space complexity is $O(n)$**: In the worst case, i.e., a full binary tree, before traversing to the bottom level, the queue contains at most $(n + 1) / 2$ nodes simultaneously, occupying $O(n)$ space.
|
|
|
|
## Preorder, Inorder, and Postorder Traversal
|
|
|
|
Correspondingly, preorder, inorder, and postorder traversals all belong to <u>depth-first traversal</u>, also known as <u>depth-first search (DFS)</u>, which goes as deep as possible before backtracking.
|
|
|
|
The figure below shows how depth-first traversal works on a binary tree. **Depth-first traversal is like "walking" around the perimeter of the entire binary tree**, encountering three positions at each node, corresponding to preorder, inorder, and postorder traversal.
|
|
|
|
|
|
|
|
### Code Implementation
|
|
|
|
Depth-first search is usually implemented based on recursion:
|
|
|
|
```src
|
|
[file]{binary_tree_dfs}-[class]{}-[func]{post_order}
|
|
```
|
|
|
|
!!! tip
|
|
|
|
Depth-first search can also be implemented iteratively, and interested readers can explore this on their own.
|
|
|
|
The figure below shows the recursive process of preorder traversal of a binary tree, which can be divided into two opposite phases: "descending" and "returning".
|
|
|
|
1. "Descending" means making a new recursive call, during which the program visits the next node.
|
|
2. "Returning" means the function call returns, indicating that the current node has been fully processed.
|
|
|
|
=== "<1>"
|
|
|
|
|
|
=== "<2>"
|
|
|
|
|
|
=== "<3>"
|
|
|
|
|
|
=== "<4>"
|
|
|
|
|
|
=== "<5>"
|
|
|
|
|
|
=== "<6>"
|
|
|
|
|
|
=== "<7>"
|
|
|
|
|
|
=== "<8>"
|
|
|
|
|
|
=== "<9>"
|
|
|
|
|
|
=== "<10>"
|
|
|
|
|
|
=== "<11>"
|
|
|
|
|
|
### 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 degenerates into a linked list, the recursion depth reaches $n$, and the system occupies $O(n)$ stack frame space.
|