Algorithms and Data Structures

N.Wirth. Algorithms and Data Structures. Oberon version 154
PROCEDURE preorder (t: Node);
BEGIN
IF t # NIL THEN
P(t); preorder(t.left); preorder(t.right)
END
END preorder
PROCEDURE inorder (t: Node);
BEGIN
IF t # NIL THEN
inorder(t.left); P(t); inorder(t.right)
END
END inorder
PROCEDURE postorder (t: Node);
BEGIN
IF t # NIL THEN
postorder(t.left); postorder(t.right); P(t)
END
END postorder
Note that the pointer t is passed as a value parameter. This expresses the fact that the relevant entity is
the reference to the considered subtree and not the variable whose value is the pointer, and which could be
changed in case t were passed as a variable parameter.
An example of a tree traversal routine is that of printing a tree, with appropriate indentation indicating
each node's level.
Binary trees are frequently used to represent a set of data whose elements are to be retrievable through
a unique key. If a tree is organized in such a way that for each node t i , all keys in the left subtree of t i are
less than the key of t i , and those in the right subtree are greater than the key of t i , then this tree is called a
search tree. In a search tree it is possible to locate an arbitrary key by starting at the root and proceeding
along a search path switching to a node's left or right subtree by a decision based on inspection of that
node's key only. As we have seen, n elements may be organized in a binary tree of a height as little as
log(n). Therefore, a search among n items may be performed with as few as log(n) comparsions if the tree
is perfectly balanced. Obviously, the tree is a much more suitable form for organizing such a set of data
than the linear list used in the previous section. As this search follows a single path from the root to the
desired node, it can readily be programmed by iteration:
PROCEDURE locate (x: INTEGER; t: Node): Node;
BEGIN
WHILE (t # NIL) & (t.key # x) DO
IF t.key < x THEN t := t.right ELSE t := t.left END
END;
RETURN t
END locate
The function locate(x, t) yields the value NIL, if no key with value x is found in the tree with root t. As in
the case of searching a list, the complexity of the termination condition suggests that a better solution may
exist, namely the use of a sentinel. This technique is equally applicable in the case of a tree. The use of
pointers makes it possible for all branches of the tree to terminate with the same sentinel. The resulting
structure is no longer a tree, but rather a tree with all leaves tied down by strings to a single anchor point