# Traversing a binary tree
In its physical representation, a tree is a linked data structure, so traversal follows pointers from node to node. Unlike a linked list, however, a tree is nonlinear. Traversing it is more complex and requires a search algorithm.
Common binary-tree traversals include level-order, preorder, inorder, and postorder traversal.
## Level-order traversal
As shown below, level-order traversal visits the tree level by level from top to bottom, moving from left to right within each level.
Level-order traversal is a form of breadth-first traversal, also called breadth-first search (BFS). It explores outward one layer at a time.

### Implementation
Breadth-first traversal usually uses a queue. A queue's first-in, first-out rule matches the traversal's level-by-level progression. The implementation follows:
```src
[file]{binary_tree_bfs}-[class]{}-[func]{level_order}
```
### Complexity analysis
- **Time complexity: $O(n)$**. Each of the $n$ nodes is visited once, taking $O(n)$ time.
- **Space complexity: $O(n)$**. In the worst case, a perfect binary tree, the queue holds up to $(n + 1) / 2$ nodes just before the lowest level is visited, requiring $O(n)$ space.
## Preorder, inorder, and postorder traversal
Preorder, inorder, and postorder traversal are forms of depth-first traversal, also called depth-first search (DFS). They follow a path to its end, then backtrack and continue.
The figure below illustrates depth-first traversal. **Imagine walking once around the outside of the entire binary tree**. At each node, you encounter three positions corresponding to preorder, inorder, and postorder visits.

### Implementation
Depth-first search is usually implemented recursively:
```src
[file]{binary_tree_dfs}-[class]{}-[func]{post_order}
```
!!! tip
Depth-first search can also be implemented iteratively. Interested readers can explore this approach themselves.
The figure below shows the recursive process for preorder traversal, with two opposing phases: descending into calls and returning from them.
1. Descending starts a new function call and visits the next node.
2. Returning ends a function call, indicating that the current node has been fully processed.
=== "<1>"

=== "<2>"

=== "<3>"

=== "<4>"

=== "<5>"

=== "<6>"

=== "<7>"

=== "<8>"

=== "<9>"

=== "<10>"

=== "<11>"

### Complexity analysis
- **Time complexity: $O(n)$**. Every node is visited once, taking $O(n)$ time.
- **Space complexity: $O(n)$**. In the worst case, the tree degenerates into a linked list, recursion reaches depth $n$, and stack frames require $O(n)$ space.