Binary search tree: traverse

Binary search tree: traverse

Genaral Information

Algorithmic problem: Sorted sequence: traverse

Type of algorithm: loop

Auxiliary data:

1. A stack S whose elements are pairs consisting of
   1. a natural number seenChildren in the range $\{0,1,2\}$ and
   2. a binary search tree node node.
2. Pointers elem and elem' to stack elements.

Abstract View

Invariant: Before and after each iteration:

1. $S$ contains all nodes on the path (called the current path) from the root to some binary search tree node (called the current node) in the order from the root to the current node (in particular, the current node is the top element of $S$).
2. Let elem be some element of the stack:]
   1. If $elem.seenChildren=0$, neither $elem.node.key$ nor one of the keys in the subtree rooted at $elem.node.right$ has been appended to $L$ so far; possibly, some or all keys in the subtree rooted at $elem.node.left$ have already been appended.
   2. If $elem.seenChildren=1$, all keys in the subtree rooted at $elem.node.left$ and, afterwards, $elem.node.key$ have already been appended to $L$; possibly, some or all keys in the subtree rooted at $elem.node.right$ have been appended as well.
   3. If $elem.seenChildren=2$, all keys in the subtree rooted at $elem.node$ have been appended to $L$

Variant: Indentify the current content of $S$ with the string of length $|S|$ over the alphabet $\{0,1,2\}$ that is formed by the $seenChildren$ values of the stack elements <in the order from the root to the current node). Then the current string immediately after the iteration

1. is either empty (which, clearly, is tantamount to $S$ being empty),
2. or it is lexicographically larger than the string immediately before the iteration.

Break condition: $S$ is empty.

Remark: The number of iterations accomplished so far is the natural induction parameter. For conciseness, the induction parameter is omitted in the following.

Induction Basis

Abstract view: Initialize $S$ with the root.

Implementation:

1. Create a new stack element $elem$.
2. Set $elem.node:=root$.
3. Set $elem.seenChildren:=0$.
4. Ensure that $S$ is empty.
5. $S.push(elem)$.

Proof: All invariants are trivially fulfilled.

Induction Step

Abstract view:

1. If the left child of the current node has not yet been examined:
   1. If the left child of the current node exists, proceed to the left child.
2. Otherwise, if the right child of the current node has not yet been examined:
   1. Append the key of the current node to $L$.
   2. If the right child of the current node exists, proceed to the right child.
3. Otherwise (that is, left and right child examined), proceed to the parent of the current node.

Implementation:

1. Set $elem:=S.top()$.
2. Set $node:=elem.node$
3. If $elem.seenChildren=0$:
   1. If $node.left\ne void$:
      1. Create a new element $ele{m}^{\prime }$.
      2. Set $ele{m}^{\prime }.node:=node.left$.
      3. Set $ele{m}^{\prime }.seenChildren:=0$.
      4. $S.push(ele{m}^{\prime })$.
   2. Otherwise:
      1. Set $elem.seenChildren:=1$.
      2. $L.append(elem.node.key)$.
4. Otherwise, if $elem.seenChildren=1$:
   1. If $node.right\ne void$:
      1. Create a new elem $ele{m}^{\prime }$.
      2. Set $ele{m}^{\prime }.node:=node.right$.
      3. Set $ele{m}^{\prime }.seenChildren:=0$.
      4. $S.push(ele{m}^{\prime })$.
   2. Otherwise, set $elem.seenChildren:=2$.
5. Otherwise, (that is $elem.seenChildren=2$).
   1. $S.pop()$.
   2. If $S$ is empty, terminate the algorithm.
   3. Set $elem:=S.top()$
   4. Set $elem.seenChildren:=elem.seenChildren+1$.
   5. If $elem.seenChildren=1$ and $elem.node.left\ne void$ then: $L.append(elem.node.key)$.

Correctness: Invariant #1 follows immediately from the fact that each push operation simply extends the current path and each pop operation cuts off the end node of the current path. Next consider Invariant #2.

Invariant #2 is trivially maintained both for $elem$ and $ele{m}^{\prime }$ in Steps 3.1 and 4.1 and $elem$ in Step 3.2 and 4.2 (note the append operation in Step 2.2, which reflects the inclusion of the current node in Invariant 2.2). In Step 5, the algorithm returns from a non-empty subtree, so the increase of $seenChildren$ and the append in case $seenChildren=1$ are correct. Note that each key is appended only once because Step 3.2.2 applies only if the left child is empty, and Step 5.4, only if the left child is not empty. Finally, consider the variant. Whenever a new element is pushed, the new string is an extension of the old string, which is clearly lexicographically larger. On the other hand, whenever an element is removed from $S$, Step 5.4 ensures that the new string is not just a prefix of the old string but is larger at the last position of the new string (which is the second last position of the old string).

Complexity

Statement: Linear in the length of the sequence in the worst case.

Proof: Each iteration of the loop takes constant time. Each node is visited in a most three iterations, viz. once with $seenChildren=0,1,2$ respectively. This obvservation proves the claim.

Pseudocode

INORDER-TREE-WALK(x)

if x ≠ NULL

INORDER-TREE-WALK(left[x])

print key[x]

INORDER-TREE-WALK(right[x])