University of Wollongong

Research Online

Department of Computing Science Working Faculty of Engineering and Information

Paper Series Sciences

1979

Trees as data structures

Alfs T. Berztiss
University of Pittsburgh, [email protected]

Follow this and additional works at: https://ro.uow.edu.au/compsciwp

Recommended Citation
Berztiss, Alfs T., Trees as data structures, Department of Computing Science, University of Wollongong,
Working Paper 79-2, 1979, 75p.
https://ro.uow.edu.au/compsciwp/3

Research Online is the open access institutional repository for the University of Wollongong. For further information
contact the UOW Library: [email protected]
 PREFACE

In these notes for a series of lectures given at the

University of Wollongong in the Winter of 1979
emphasis is on the structural aspects of trees, i.e.,
there is little concern with properties related to the
information content of trees. Hence nothing will be
found here on, for example, optimization of weighted
trees, B-trees, or decision trees as used in artificial
intelligence work.

Some'of the material is an adaptation of the auhtor's

research results. This research was partly supported
by the National Science Foundation of the United
States under Grants GJ-4l683 and MCS 77-01462.

A. T. Berztiss
Department of Computer Science
University of Pittsburgh
Pittsburgh, PA 15260, U.S.A.
 TREES AS DATA STRUCTURES

1. TREES AND THEIR REPRESENTATION 1

1.1 Trees and binary trees 1
1.2 Traversals of trees 3
1.3 Algorithms for binary tree traversals 6
1.4 Storage representations of trees, 10

2. SEARCHING, SORTING, AND TREES 16

2.1 Heaps and binary search trees 16
2.2 Recurrence relations with constant
coefficients 20
2.3 Generating functions in the solution
of recurrences 24
2.4 Recurrence relations with variable
coefficients 28
2.5 Effect of balancing on binary search trees 29
2.6 Analysis of search in AVL trees 33
2.7 Insertions and deletions in AVL trees 36

3. GRAPHS AND K-TREES • 42

3.1 Representation of digraphs by K-trees 42
3 •. 2 Depth-first search algorithms and K-trees 46
3.3 Algorithms that change the structure
of K-trees 56
3.4 K-trees of undirected graphs 60
3.5 K-trees and K-formulas 62

4. A PHILOSOPHY OF DATA STRUCTURES 68

4.1 Trees as abstract data structures 68
4.2 Levels of abstraction 71

FURTHER READING • 75
 1. TREES AND THEIR REPRESENTATIOlll

1.1 Trees and binary trees

A connected acyclic graph G = <V, E >, where V is its set

of ~ and E its set of edcl.£.§.. is a tree. Designate some
rEV as the root of the tree. Then G becomes a rooted tree.
If a node in a rooted tree is not the root of the tree and has
just one node adj acent to it l' then it is a leaf or terminal node;
else it is an internal node. Every edge of a rooted tree lies
on some path from the root to a leaf. If a direction is
assigned to every edge, the 1:ree becomes a directed tree. An
edge with direction is an ~~. The usual convention (and the
one followed here) is to require that every arc in a directed
tree be directed away from the root. In drawings of digraphs
arcs are represented as arrm"s. This is rarely done in drawings
of directed trees. Instead the direction is implicitly
indicated by placing the taU of an arc above its. head. Suppose
several arcs have the same node as their taiL When the left-
to-right order of the heads of these arcs is important we speak
of an ordered directed tree. These latter structures have
greater significance to computer science than the more general
trees, and in what follows the term ~ will be used as short-
hand for ordered directed tree.
Consider node n in a tree. Nodes reachable from n are
descendants of n, and nodes 'that are heads of arcs whose tail is
n are successors of n. All nodes that have n as descendant are
ancestors of n, and the ancestor nearest to n is the parent of
n. Consider the nodes that have the same parent in their left-
to-right order. The nearest node to the left (right) of node n
is its left (right) neighbour.
A tree in which no more than k arcs originate from a node
is a k-nary tree (binary whe::1 k=2, ternary when k= 3). In a
binary tree, whenever -two arcs originate from a node, one of the
arcs goes to the left, and the other to the right. However,
 2

c
when there is just one arc originating from a node, it is still
s
possible to impose a left or right orientation on this arc, and,
if this is done, the binary tree becomes oriented. It is common
practice to reserve the term binary tree for structures that
would be more precisely called oriented binary trees.
The level of a node in a tree is the length of the path
(i.e., the number of arcs on the path) from the root to this
node. The level of the root is thus zero. The height of a tree
is the greatest level assignment given to a node in the tree,
i.e., it is the length of the longest path from the root to-a
terminal node.
i
Level i of a binary tree is full if there are exactly 2
nodes at this level. A binary tree of height k is full if
level k in this binary tree is full -- level k being full implie
of course, that levels k-l, ..• ,l,O are all full. A binary tree
of height k is balanced if level k-l in this binary tree is fu1] 1
Consider node n in a binary' tree. The binary subtree-rooted at
the left successor of n is the left subtree of n, and that
rooted at the right successor is the right subtree. A binary t
tree is height balanced (or an AVL-tree, after Ade1son-Ve1skii a
and Landis) if, at every node in the tree, its left and right F
subtrees differ by no more than 1 in height (for the purposes
of this definition a tree that does not exist has height -1
for example, if a node has no left successor, and its right
successor is a leaf, the heights of its left and right subtrees
are -1 and 0, respectively).
Every tree can ~e transformed into a binary tree by means
of the following procedure, which has become known as the t
Knuth transformation: i
Denote the arcs originating at internal node x in a tree o
by <x'Yl' <x'Y2 , ... , <x,y? Assign left orientation
to arc <x'Yr ' and replace the remaining arcs by arcs 0:

<Yl'Yt '<Y2'Y3>'''''<Yt-l'Y?' all with right orientation.

After this has been done for all internal nodes of the
tree the result is a binary tree that contains the same
number of arcs as the original tree.
Note that the transformation is reversible, i.e., that a tree
 3

an be reconstructed from its Knuth transform. Figures 1 and 2

how a tree and its Knuth transform, respectively.

Figure 1 Figure 2

.2 Traversals of trees

The three classical disciplines of traversal of binary

rees -- prcordcr, inorder (or symmetric order), postorder --
re well known and well understood. For the binary tree of
ig. 2 they generate the following sequences:

pre 1- 2 6 7 3 8 4 5 9 10 12 11
in 6 7 2 8 3 4 9 12 10 11 5 1 (1)
post 7 6 8 12 11 10 9 5 4 3 2 1

Now extend the definitions of preorder and postorder

raversa1s to arbitrary trees. Pre order traversal: At each node
n the tree, process the node and then proceed to the successors
f the node in left-to~right order. Postorder traversal: At each
ode, proceed to the successors of the node in left-to-right
rder, and then process the node. For the tree of Fig. 1 we have

T-pre 1 2 6 7 3 8 4 5 9 10 12 11
(2)
T-post 6 7 2 8 3 4 9 12 10 11 5 1

Jmparison of (2) with (1) shows that preorder traversal is

 2

when there is just one arc originating from a node, it is still

possible to impose a left or right orientation on this arc, and,
if this is done, the binary tree becomes oriented. It is common
practice to reserve the term binary tree for structures that
would be more precisely called oriented binary trees.
The level of a node in a tree is the length of the path
(i.e., the number of arcs on the path) from the root to this
node. The level of the root is thus zero. The height of a tree
is the greatest level assignment given to a node in the tree,
i.e., it is the length of the longest path from the root to'a
terminal node.
i
Level i of a binary tree is full if there are exactly 2
nodes at this level. A binary tree of height k is full if
level k in this binary tree is full -- level k being full implies,
of course, that levels k-l, ... ,l,O are all full. A binary tree
of height k is balanced if level k-l in this binary tree is full.
Consider node n in a binary' tree. The binary subtree· rooted at
the left successor of n is the left subtree of n, and that
rooted at the right successor is the right subtree. A binary
tree is height balanced (or an AVL-tree, after Adelson-Velskii
and Landis) if, at every node in the tree, its left and right
subtrees differ by no more than 1 in height (for the purposes
of this definition a tree that does not exist has height -1
for example, if a node has no left successor, and its right
successor is a leaf, the heights of its left and right subtrees
are -1 and 0, respectively).
Every tree can be transformed into a binary tree by means
of the following procedur~, which has become known as the
Knuth transformation:
Denote the arcs originating at internal node x in a tree
by <x,Yf ' <x,Yi , ... , <x'Yl' Assign left orientation
to arc <x,Yf ' and replace the remaining arcs by arcs
<Yl,Yt '<Y 2 'Y3>""'<Y t -l'Yj?' all with right orientation.
After this has been done for all internal nodes of the
tree the result is a binary tree that contains the same
number of arcs as the original tree.
Note that the transformation is reversible, Le., that a tree
 3

can bd reconstructed from its Knuth transform. Figures 1 and 2

show a tree and its Knuth transform, respectively.

Figure 1 Figure 2

1.2 Traversals of trees

The three classical disciplines of traversal of binary

trees -- preorder, inorner (or symmetric order), postorder --
are well known and well understood. For the binary tree of
Fig. 2 they generate the following sequences:

pre 1 2 6 7 3 8 4 5 9 10 12 11
in 6 7 2 8 3 4 9 12 10 11 5 1 (1)
post 7 6 8 12 11 10 9 5 4 3 2 1

Now extend the definitions of preorder and postorder

traversals to arbitrary trees. Preorder traversal: At each node
in the tree, process the node and then proceed to the successors
of the node in left-to~right order. Postorder traversal: At each
node, proceed to the successors of the node in left-to-right
order, and then process the node. For the tree of Fig. 1 we have

T-pre 1 2 673 8 4 5 9 10 12 11
(2)
T-post 6 7 2 8 3 4 9 12 10 11 5 1

Comparison of (2) with (1) shows that preorder traversal is

 4

invariant under the Knuth transformation, but that postorder

traversal of a general tree is equivalent to inorder traversal
of its transform. This observation permits us to advance an
alternative definition of prcorder and postorder traversals of
trees. Preorder (postorder) traversal: Process nodes in the
order they would be processed in the Knuth transform of the tree
under preorder (inorder) traversal.
Preorder traversal is also known as depth-first traversal.
If we wished to explore a tree ina breadth-first manner, we
would be employing breadth-first or levelorder traversals. A
traversal whose direction is from .left to right will be
designated to be of type LR, and one whose direction is right to
left to be of type RL. We then have, for the binary tree of
Fig. 2,

LR-levcl 126 3 7 8 4 5 9 10 12 11
(3)
RL-level 123 6 4 8 7 5 9 10 11 12

and for the general tree of Fig. 1,

T-LR-level 1 2 3 4 567 8 9 10 11 12
(4)
T-RL-level 154 3 2 11 10 9 8 7 6 12

It is of interest to determine what levelordertraversals

(4) become in the transform. In the equivalent to LR-levelorder
traversal of a general tree we are moving down diagonally from
upper left to lower right (LR-down). In the equivalent to
RL-levelorder we move from ,lower r~ght to upper left (RL-up).
So, for the binary tree of Fig. 2 we obtain two new traversal
sequences:

LR-down 1 234 5 6 7 8 9 10 11 12
(5)
RL-up 1 543 2 11 10 9 8 7 6 12

Let us now introduce two operators on traversals, R (for

reverse) and C (for converse). Under R(t) nodes of a binary tree
are processed in an order that is the exact opposite of the order
in which they are processed under traversal t, and C(t) is
 5

equivalent to traversal t in a binary tree that has been

flipped over, thus interchanging the meaning of left and right.
For the binary tree of Fig. 2 we now have

R(pre) 11 12 10 9 5 4 8 3 7 6 2 1
R(in) 1 5 11 10 12 9 4 3 8 2 7 6 (6)
R (post) 1 2 3 4 5 9 10 11 12 8 6 7

C (pre) 1 2 3 4 5 9 10 11 12 8 6 7
C (in) 1 5 11 10 12 9 4 3 8 2 7 6 (7)
C(post) 11 12 10 9 5 4 8 3 7 6 2 1

Note that

R(pre) C (post) ,
R(in) C (in) (8)
R(past) C(pre)

Indeed, we can relate the three classical'traversal disciplinp.s

and their converses by the diagrams of Fig. 3.
Now, if we apply the C and R operators to LR-level, LR-down,'
RL-up, we obtain in each instance three new traversals, as shown
in Fig. 4. Th8se nine new traversals are distinct from the nine
traversals defined earlier, as can be seen by comparison of (1),
(7), (3), and (5) with (9) below, where we give the sequences
obtained when the nine traversals are applied to the binary tree
of Fig. 2.

pre III
R
.. C (post)
ct
C (pre) " ~
tc
post
R

R,C
in • ~ C(in)

Figure 3
 6

R
LR-level ....t ---........ R (LR-level)

C t
RL-level .....t----'l~~ R (RL-level)
t
c

LR-down .... R
~ R (LR-down)

ct
RL-down 4 ~
tc
R(RL-down)
R

R R(RL~up)
RL-up ~ ~

LR-up
t ... ....
t
c
R(LR-up)
R

Figure 4

RL-1eve1 1 2 3 6 4 8 7 5 9 10 11 12
R (LR-leve1) 11 12 10 9 5 4 8 7 3 6 2 1
R(RL-1eve1) 12 11 10 9 5 7 8 4 6 3 2 1
RL-down 1 2 6 3 8 7 4 5 9 10 12 11
R(LR-down) 12 11 10 9 8 7 6 5 4 3 2 1 (9)
R(RL-down) 11 12 10 9 5 4' 7 8 3 6 2 1
LR-Up 6 2 1 7 8 3 4 9 5 12 10 11
R(RL-up) 12 6 7 8 9 10 11 2 3 4 5 1
R(LR-up) 11 10 12 5 9 4 3 8 7 1 2 6

1.3 Algorithms for binary tree traversals

The classical traversals and their reverses (or converses)

correspond to the six permutations of statement.s X,Y,Z in the
schema

procedure traverse (root) ;

(10)
begin {X,Y,z} end;
where
X: process node;
Y: if left exists then traverse ( left);
z: if right exists then traverse (right);

The ordering of X,Y,Z in (IO) defines the traversals as follows:

pre XYZ R{pre) ZYX C(pre) XZY

in YXZ R{in) ZXY C(in) ZXY
post YZX R(post) XZY C (post) ZYX

Note that the order of the statements for R{t) is exactly the
reverse of that for traversal t, but that C(t) is obtained from
t by interchanging Y and Z alone.
Let us now remove recursion from schema (IO) by the intro-
duction of an explicit pushdown store.

procedure traverse (binary tree) ;

begin PDI := X' ;
PDI+- root;
while PDI t X' do
begin node .... POI;
if node marked then process node
else begin {A,B,C} end
end

where

A: mark node; PDI.-node;

B: if left exists then PDI'-left;
C: if right exists then PDI~right;

Now, pushdown store POI may be either a sta~ or a queue.

If it is a staGk then the permutations of A,B,C still define
the three classical traversals and their converses (or reverses),
as follows:
 8

pre CBA C(pre) BCA

in CAB C(in) BAC
post ACB C(post) ABC

If POl is a queue then the nodes of the binary tree are

processed in RL-levelorder irrespective of whether the order
of A,B,C is CBA, CAB, or ACB. Similarly, LR-levelorder is
obtained with permutations BCA, BAC, ABC. In other words, the
three classical orders all map to RL-levelorder, and their
converses (or reverses) to LR-levelorder.
Under schema (11) each node of the binary tree is pushed
down twice. It is possible to refine (11) specifically into
a procedure for preorder traversal in which each node is
pushed down only once.

procedure preorderl (bitree) ;

begin POl := ~ ;
P01..-root;
repeat node + POl;
process node;
if right exists then rOl + right;
if left exists then POl +left
until POl = }1

Procedure preorderl still processes the nodes of a binary tree

in RL-levelorder when POl is a queue.
Let us refine the procedure still further. We note that
when "POI + left" is executed its execution is followed
immediately by "node + POI", and we take advantage of this.

procedure preorder2 (bitree);

begin POI: = ~;
POI'" root;
repeat node + POI;
noleft: = false;
repeat process node;
 9

if right exists then PDI -<- right;

if left exists then node: = left
else noleft: - ~

until noleft
until PDI = ;r
end;

SUbstitution of queue for stack in preorder2 produces a

procedure for RL-downorder.
In the next modification, instead of processing nodes
directly as they are taken off PDI or reached in tracing left
successor chains in the inner repeat-until loop, we save them
up in a second pushdown store. This modification cannot be
called a refinement because there is now a substantial increase
in cost over that of preorder2. In addition to the activities
associated with PDI, which is utilized in exactly the same manner
as in preorder2, now every node gets pushed down exactly once on
the second pushdown store.

procedure preorder3 (bitree);

~ PDI: =~: PD2: = ~;
PDI -<- root;
repeat node -<- PDI;
noleft: =~;

repeat PD2 -<- node;

if right exists ~ PDI -<- right;
if left exists then node: = left
else noleft: ~

until noleft;
repeat node -<- PD2;
process node
until PD2 == ~

until PDI == ~

The behaviour of preorder3 is expressed in the following table:

 10

PDl PD2 Traversal

stack queue preorder
stack stack LR-uporder
queue queue RL-downordcr
queue stack (nonstandard)

Let us summarize our results on traversals of binary trees.

We have defined 18 distinct and meaningful traversal disciplines,
and shown that they can all be derived from five basic disciplines
by means of operators Rand C. It should be noted that the two
operators are fundamentally different: C operates on an algorithm
(it interchanges the meaning of left and right); R operates on the
node sequence produced by an algorithm. Only in the special case
of the schemas for the classical traversals, e.g. (11), does R too
function as an operator on an algorithm. We shall designate the
following five traversals as our set of basic traversals:

preorder
inorder
lU.-levelorder
RL-downorder
LR-uporder

Fig. 5 shows how the procedure~ fer generating these traversals

are related.

1.4 Storage representations of trees

A tree can be represented by a set of arc lists, one for each

internal node. For example, the tree of Fig.l has the following
arc list representation:

1: 2,3,4,5
2: 6,7
3: 8 (12)
5: 9,10,11
10: 12
 11

traverse with -----~ traverse with

permutation CBl\. permutation CAB

INOROER

preorderl with ~ preorderl with

POl - queue POl - stack

RL-LEVELORDER

preorder2 with +--1' preorder2 with

POl - queue , PDl - stack

RL-OOWNORDER

preorder3 with ~I preorder3 with

POI - stack Pol - stack
P02 - stack PD2 - queue

LR-UPORDER

PREORDER

Figure 5
 J.L

The unequal lengths of the arc lists create some problems in

the design of a space-efficient storage structure. Also, in
many applications one has to provide for addition and deletion
of arcs, and the storage structure should permit this to be
done reaso,-ably efficiently.
For a binary'tree each arc list contains at most two
entries. If each arc list is made to have exactly two elements,
then it is possible to indicate orientation of an arc: the
head of an arc with left orientation is stored in the first
element, the head of an arc with right orientation in the
second element. This uniformity in the representation of
binary trees is one reason for mapping arbitrary trees to
binary trees by means of the Knuth transformation. The only
disadvantage in operating with the transform is that path
lengths in the transform are greater than in the original tree.
For example, the length of the path from node 1 to node 11 is
only 2 in the tree of Fig. 1, but 7 in the transform (Fig.2).
We have, for the binary tree of Fig.2:

1: 2, -
2: 6, 3
3: 8, 4
4: 5
(13)
5: 9, -
6: 7
9: 10
10: 12,11

It is customary to provide arc lists for terminal nodes as

well, although both elements in such lists are empty. Thus, if
the nodes are numbered 1,2, ... ,n, the set of arc lists can be
stored as an array of n rows and two columns. Names of arc
lists are now provided implicity by the row subscripts.
This approach has the further advantage that the empty
locations can be used to hold threads, which can be very useful
in the implementation of some iterative traversals of the
binary tree that do not then .require a pushdown store. For
example, if the second linkage element,in the row for node n
is empty, i.e., if n has no right successor, tten this element
can be made to hold the node that follows node n under
 13

inorder traversal, i.e., it is then a thread from n to

this node, called the right thread. Similarly, if the
first linkage element is empty, it can be made t? hold a
left thread from n to the node that precedes it in the
inorder sense. A binary tree with right threads is a right
threaded binary tree, one with both right ~nd left threads
is a fully threaded binary tree. Fig. 6 shows the fully
threaded representation of the binary tree of Fig. 2, where
the threads are distinguished from successor links by flags
(*). Since the inorder sequence begins at 6 and ends at 1,
there is no left thread for node 6 and no right thread for
node 1.

1: 2
2: 6 3
3: 8 4
4: 3* 5
5: 9 1*
6: 7
7: 6* 2*
8: 2* 3*
9: 4* 10
10: 12 11
11: 10* 5*
12: 9* 10*

Figure 6

An algorithm for inorder traversal of a right threaded

binary tree:

procedure inorder (bitree);

begin node: = root;
alldone: = false;
repeat if left existsAnode not reached by thread then
node: = left
else begin process node;
if right exists then node: right
 14

else if thread exists then node:

else alldone: ~ true
end
unti 1 allclone

A similar algorithm based on right threads alone can be

defined for preorder traversal. The algorithm for postorder
traversal is more complicated and requires full threading. Age
if there exists an algorithm for traversal t, the algorithm fOI
C(t) is obtained by simply interchanging left and right in the
algorithm t. This means, of course, that left threads have to
be provided before the modified algorithm for inorder traversal
can be applied to a binary tree for C(inorder).
By means of right threads one can easily determine in the
Knuth transform of tree T the parent of node n with respect to

node: = nj
while right exists do node: rig~tj

parent: = thread;

On occasion, in case the tree is stored on disk, it may be

convenient to determine first whether or not a node has a
particular successor rather than try to retrieve the (possibly
nonexistant) successor. This is achieved by means of bit vectol
where for the binary tree of Fig. 2 we have:

1 2 3 -4 5 6 7· 8 9 10 11 12
1 1 1 0 1 o o 0 o 1 o o (14 )
o 1 110 1 o 0 1 1 o o

A very dense binary tree, i.e., one close to being fUll,

can be represented by a vector tree. Consider the binary tree
1
of Fig.7. Its height is 3. Take a vector of 15(=2 3 + -1)
elements. Store the r:oot in tree [1.]" Then for each node
already stored in the array, if the node is stored at tree[kJ,
store its left and right successors at tree[2*k] and tree[2*k+l]
respectively.
 15

The result here is

1 2 3 4 567 8 9 10 11 12 13 14 15
(15)
9 8 6 4 7 3 2 1 5

Additions and deletions can be handled quite easily, provided

they do not change the height of the binary tree upward.

Figure 7
 16

2. SEARCHING, SORTING, AND TREES

2.1 Heaps and bi nary seaJ:ch trees

Trees are often used to express relationships between

records in a file. The n,cords are regarded as occupying the
nodes of a tree, and the relative location of two nodes in the
tree implies some relatior.ship between the keys of the records
associated with these nodEs. Consider node numbers 1,2, ..• ,9
in the binary tree of Fig. 7 as keys. Here the tree has the
heap property, which means that for any node the key at this
node is larger than the keys at its successor nodes. Consequent
the largest key in the entire file is at the root of the tree,
and the second largest is at one of the successors of the root.
rhe significance of this is that a binary tree with the heap
property functions as a Q~~ri~y queue, i.e., irrespective of
the changes that it may un:'lergo, it provides inunediate access
to the largest of the keys stored in it at anyone time.
If a binary tree that has the heap property is balanced,
then it can be stored very compactly, and it is easy to provide
o (log n) algorithms for addition and deletion of nodes that
maintain both the h~ap property and balance. Using the storage
concept expressed by (15), the following array (to which we give
the name heap) corresponds to the binary tree of Fig. 8.

i 1 2 3 4 5 6 7 8 9
(16)
heap [iJ 9 8 4 7 5 1 2 3 6

A~
3 6

Fi1lure 8
 17

suppose exactly one node k in a oinary tree of n nodes is

responsib!e for the heap property not holding. This node may
either have to be bubbled up until the heap property is
restored, or it may have to be shifted down in the tree. The
following procedures perform these two tasks.

procedure bubbleup \ heap, k};

begin ordered: = false;
repeat parent: = k div 2;
if parent = 0 then ordered: = true
else if hea~k] < heap[parent] then ordered:= true
else begin swap hea~k] and heap[parent];
k: = parent
end
until ordered

The procedure for shifting down is slightly more complicated

because now it has to be first established which of the two
possible successors of the node is the greater, because, in case
a swap is required, it is with this successor. The complications
arise out of the need to deal with cases in which the node has
no successors or just one successor.

procedure siftdown (heap, k, n);

begin ordered: = false;
repeat next: = 2*k;
if next) n then ordered: true
else
begin if next = n then hi: = next
else if heap[next] > heap[next+l] ~ hi:=next
else hi: = next+l;
if heap[k] >heap[hi] then ordered:=~
else swap heap[k] and heap[hi];
k: = hi
end
until ordered
 18

With these procedures the basic heap operations become very

easy to implement.

(i) Building a heap of n elements.

for i: = I to n do
begin read (datum);
heap[i]: = datum;
bubbleup (heap,i)

(ii) Deletion of an element. Suppose element heap[j] is ·to be

deleted. This is effected by moving heap[n] into the vacated
location, and then restoring the heap property to the remaining
n-l elements.

temp: = heap[j];
heap[j]: = heap[n];
if heap[j]) temp then bubbleup (heap,j)
else siftdo~n (heap,j,n-l);

The creation of the heap is the first phase of an O(n log n)

sorting procedure known as heapsort or treesort. The second
phase is extremely simple:

for i: = ndownto 2 do
begin swap heap[l] and heap[i];
siftdown (heap,l,i-l)

At the end of the k-th iteration the k largest keys are in their
final positions, and, since the tree of the remaining n-k
keys possesses the heap property, the largest of these keys is
in heap [1], ready to be shifted into hea~[n-k]at the start of the
next iteration.
The search tree prooerty of binary trees is similar to the
tree property: for each node, the key at the left successor is
smaller and the key at the right successor larger than the key
at the node. Keys 1,2, ... ,9 have to be qssigned to the binary
 19

tree of Fig. 8 in the manner of Fig. 9 for this tree to have

the search tree property.

Figure 9

For a given tree shape and a given set of keys there is

just one search tree, but there may be more than one heap.
However, for a given set of n keys one can construct search
trees of (2g)/\n+l) distinct shapes. The numbers (2g)/(n+1) are
known as Catalan numbers or Segner numbers. When anyone of these
search trees is traversed under inorder, the result is a sorted
sequence of the keys -- here the interpretation of "process node"
is "append the key associated with the node to the sequence of
keys being generated".
The height of a balanced binary tree is O(log n). Hence
the cost of retrieving an element or inserting a new element
in a balanced binary search tree is at most O(log n). However,
insertion may require subsequent reorganization of the tree.
Note now that the height of an AVL tree is also O(log n), and
for binary search trees that have the AVL property it is relatively
easy to show that a new node can be inserted or an existing node
deleted, and the tree reorganized ~o that the AVL property is
preserved, in time bounded by O(log n). This means that an AVL
search tree of n nodes can be grown in time O(n log n), and that
consequently an O(n log n) sorting procedure can be based on the
search tree as well.
Further in this chapter the retrieval properties of balanced,
height balanced, and arbitrary binary search trees will be
compared. This analysis will be based on the solution of
recurrence equations, and the next three sections are devoted to
this topic, which is of major importance in the analysis of
algorithms.
 20

2.2 Recurrence relations with constant coefficients

The expression

(17)

where all c are constants is a k-term lincRr recurrence relation

i
with constant coefficients. Suppose (17) is used to compute a
sequence [a ,a ,a , ... J. Since it computes an from its k-l
l 2 3
predecessors, the initial k-l members of the sequence must be
known before any computing can begin. These values are called
the boundary values. Here we n'eed boundary values a ,a ,·· • ,a - l
l 2 k
to compute a • We shall be interested in solving recurrence
k
relations rather than in using them to generate sequences, but
for a fully determined solution of a k-term relation we shall
still need k-l boundary values. Recurrence relations are often
called just recurrences, or they are called difference
equations.

Examples:

1. The number of moves required to solve the Towers of

Hanoi problem is defined by the two-term recurrence
an - 2a n _ l = 1, with al=l. (18)

2. The Fibonacci sequence [,1,1,2,3,5,8,13,2l, ••. J is

defined by the 3-term recurrence relation
an - a n - l - a n - 2 = 0, with al = a = 1. (19)
2

3. Let a n be the max. number of pieces into which a pancake

can be sliced with n cuts. These pancake numbers are defined by
a a = n (nU) , with a =1 (20)
n n-l 0

Let us try to solve from first principles the Fibonacci

recurrence (19), which we rewrite as

(19a)
o.

Try different forms for an'

 21

a. If we set an = cn+d, where c and d are constants, then

we o!)tain a n + l = c (n+l)+d and a n + 2 = c(n+2)+d, and, on substitu-
tion into (19a) and simplification, we obtain

-cn + c - d 0,

which leads to the contradiction n = (c-d)/c.

b. Similar contradictions arise with any polynomial form
for an'
c. Try an dn. Then

o d n +2 _ d n+l _ d n
n 2
d (d - d - 1).

Hence d 2 - d - 1 = 0, giving d (1 ± 15)/2. In the most

general form the solution is

(21)

Now make use of boundary values a 1. Solving the

l
simultaneous equations

*
gives c : 1//5, c -1//5. Thus
l 2

[[1~/5) n _ (1;/5(] (22)

Specification of (21) did already require a certain measure

of sophistication. Let us now express it as a systematic
procedure for solving linear recurrence relations with constant
coefficients. Equation (17) with the right hand side set to
zero is known as a homoaeneous eouation, and we start by finding
the solution to this equation. This S91ution is called the
 22

homQ.Y!'r. ..." _ ~'2-l11_~_0~ un (h), and in the theory of recurrence

equations it is e~;tablishcd that a homo~cneous linear recurrence
relation has a solution of the form

a (h) n (23)
Aa .
n

Taking (17) with the right hand side set to zero, and making
substitution (23), we obtain

0,

which simplifies to

(24)

This is the characteristic eouation of the recurrence relation.

The roots of (24) are called charact~ristic r02~, and (24) has
k-l such roots, which need not all be real or distinct. Our
discussion will ce restricted to the case of dis~inct real roots.
Let the characteristic roots be denoted a ,a , .•• ,a _ . Then
l 2 k l
an = AlaIn satisfies the homogeneous equation with any AI' and
so does a = A a n with any A , etc. A deterministic homogeneous
n 2 2 2
solution must contain all the characteristic roots. It is

(25)

in which the constants are determined by means of the boundary

values.

Example: The Fibonacci recurrence is ho~ogeneous, and the

2
characteristic equation is a - a - I = O. It has the two
distinct roots a
1
= (1+/5)/2, a
2
(1-/5)/2. Hence

(26)

and the constants are found as before.

 When the right hand side of (17) is not zero, then solution
(25) is incomplete in that it reduces the left hand side to
zero, which then does not correspond to the nonzero right hand
side. The homogeneous equation has to augmented by a particular
co1ution a (p), and the total solution is now
=--- n

a (h) + a (p) (27)

n n

We expect a (p) to have the same form as the right hand side
n
of (17).

Examples:
n
1. The homogeneous solution of (lB) is A2 • For the
particular solution try the constant B. The substitution
n
B-2B = 1 gives B = -1. Hence the total solution is A2 -l, and
initial value a = 1 establishes A = 1. WARNING: Constants Ai
l
are not to be evaluated before the total solution has" been
n
derived. Here, if al=l had been used in an (h) = A2 , we would
have obtained A=~.

2. The most skewed AVL tree of height n has the two

subtrees of every internal node differing in height by exactly
1. The number of nodes in such a tree obeys the recurrence

(2B)

with boundary values a =l, a =2. ~e already have a (h) -- it

o l n
is given by (26). Try an (p) = k. Substitution into (2B) gives
a (p)
n
= -1 ' and we get

(29)

Here we obt\!li\'1 Al = 1 + 2//5, A = 1-2//5.

2

3. The characteristic equation of an + a - l - 2a _

n n 2
2
is a + a - 2 = 0, with solutions a =.-2, a = 1. Hence
l 2
 24

n
an (h) = Al (_2)n + A • For the particular solution try B2 . Then
2
n
B2 n + B2 n - l - 2B2 - 2 = 2 n , or 2B + B - B = 2, giving B=l. Hence
n
an = (-2)n Al + A + 2 , where Al and A are determined from
2 2
boundary values.

4. The characteristic equation of the pancake recurrence

an - a
n-
1 = n is u-l = 0, and hence a
n
(h) = A. However, when

we try an(P) = Bn, we get Bn - B(n-l) = n, which results in the

2
contradiction B=n. Hence we try next a (p) = Bn + Cn. Substi-
n
tution of this into an - a n - l = nand a n - l - a n - 2 n-l gives
two simultaneous equations in Band C, which have the solution
B = C =~. The boundary value ao=l next establishes that A=l.
Hence an = 1 + ~n(n+l).

2.3 Generating functions in the solution of recurrences

We just saw in the case of the pancake recurrence that the

particular solution does not always have the form of the right
hand side of (17). The use of generating functions simplifies
the solution of (17) in that it permits us to find the total
solution without us having to consider its two components separatl
Generating functions are used extensively in combinatorics
because they make sequences of numbers amenable to mathematical
analysis. Suppose we have the sequence [a ,a l ,a "'.J Instead
o 2
of manipulating the sequence we operate instead on

(30)

the generating function of sequence [a ,a ,a , ... J. The fo(x),

o l 2
fl(x), f (x), '" are indicator functions. Any set of linearly
2
independent functions could serve as the set of indicator
functions, but for ease of manipulation the most commonly used
indicator functions are the monomials f. (x) = xi (i=0,1,2, .•. ).
~
We shall use these functions exclusively. Then

F(x) = \~ (31)
t 1 =o

The benefits that derive from the use of generating functior

are a consequence of the operations that can be performed on then
Some examples follow:
 25

a. Change of formal mark. L;t F{x)generatlO [a o ,a l ,a 2 , .. ·]·

Then F(cx) generates [a o ' alc, a 2c , ... ]. Example: ~[F{X) +

F(-x)] and l.j[F{x) - F{-x)] generate [a ' a , a 4 , ... ] and

o 2
k l , a 3 , a 5 , ... ], respectively.

b. Addition. If F{x) generates [a o ,a l ,a , •.. ] and G(x)

2
generates [bo' b , b 2 , •.• ], then F(x) + G{x) generates
l
[ao+bo ' al+b l , a 2 +b 2 , ... ].

c. MUltiplication. If F(x) generates [a ' a , a 2 , ... ]

o l
and G(x) generates [ b o ' b l , b 2 , .•. ], then F(x)G(x) is the
generating function of [co 'c l ,c 2 , ... ], where

d. Differentiation. If F(x) is the generating function of

[a ' a l , a 2 , ••• ], then
o

HencexP'(x) generates [oxa o ' lxal' 2 xa 2 , " ' ] ' .

Perhaps the most important generating function is the one
that generates [1,1, ... J. Let us write down two mathematical.
facts needed for its derivation.

a. The binomial theorem for exponent n a negative integer:

~ (rn) x n-r a r + •••. (32)

(This is really an expression that holds for n any integer

When n is a positive integer the series terminates with
n
(R)xOa = an.)

k (r+k-l) for k an integer.

b. (-~ J = (-1) k)

Then 1 (l-x) -1 1 [-i)x + (-~]x2 -

l-x
::: 1 + tiJ x +
2
(~] x
2
+
.. 1 + x + x + ••• ,
 26

i.e. -11 generates D.,l,l, •..]. We have an interesting

-x 2
special case of F(x)G(x) when F(x) = a 0 + alx + a x + •••
2
1 2
and G(x) = I-x 1 + x + x + ••• Then -11 -x
F(x) is the generatir.
function of [a ' a o +a , a +a l +a , ..•]. For this reason l=x is
o l o 2
sometimes called the summing operator.

Example: Find L~=l k • Here the approach is to find first the

2
generating function of [0 2 ,1 2 ,2 2 , •.• ], apply the sunming operator
n
to it, and pick out the coefficient of the term in x from the
result.

Solution: Since
d 1 -x
r=x
1
generates [1,1,1, •.. ], we have that
d d 1
x dx(i-x] generates [0,1,2, .•• ], and x dX(x dx generates (I-X]]
2 12 2 2 ] Th
[0 , , ,.... e ~ eren ~at~on resu ts ~n (I-x) 3, whO~c h ,
dOff t" l ' x(l+x)
. x(l+x)
on application of the summ~ng operator becomes (I-x)'. The

binomial theorum (32) teas us that (l~X)~ = L ~=o (3~iJxi.

3 n- 2)
"
Hence th e coe ff ~c~ent 0
f xn °
~s n-l) + lr +
(3+n-l) n-2 ., whO~c h , on
C

evaluation, becomes n(n+1) (2n+l)

6

Let us return to the solution of recurrence relations.

Again take the Fibonacci recurrence (19), an - a _ - a - 0,
n 1 n 2
which is valid for n ~ 3 with boundary values a = a = 1.
l 2
Choosing a =1 makes it valid for n=2 as well. .we mUltiply the
o n
equation by x and sum it from n=2 to n=~:

r:=2 a nx n ~oo
l. n=2 an_Ix
n
- r"n=2 a n-2 x n O. (33)

Now, in terms of F(x) as defined by (31) ,

[F(x)-ao-alx] - X[F(x)-a ] - x 2F (x) O. ,

o

or F (x) x
l-x-x 2

and we next have to restore F(x) to the form (31). By the method
 27

of partial fractions, we get

x
F(x) (I-cx) (l-dx)

1 [ cx dx ],
c-d l-cx l-dx .

1+.5 1- 15 cx
where c -2-' d -2-' But
1-cx

F (x) 1 \~ (ck_dk)xk,
Hence c-d l k=O

1 r(l+ls)n _ (1-1s )n]

an 75 L-2-) l-2-

Now consider the pancake cutting problem, as defined by

recurrence (20). Carry out the summation:

(34)

Deal first with the last term. We have

1 _ 1 + x + x 2 + x 3 + •••
I-x -

Hence, 1 1 + 2x + 3x 2 + 4x 3 + •••
-(l-X) 2

and
x 234
nx •
n
(1~x)2 = X + 2x + 3x + 4x + •••

x
Substitution into (34) gives F(x)-a
o = xF(x) + rr=xr2, and, since a o =l,

F(x) = x + 1
(I-x) 3 (l-x)

We know that (l-x)

1
3 generates[(~), U), ... , (l~~), ... ], and

(2~k)= ~(k+l) (k+2). Hence the sequence generated by (I-x)

x
3
.
1.S

1
[0,1,3, ... ,~k(k+l) , ... ], and, since I-x generates [1,1,1, ••. ,1, ••• ],

we have

an ~n(n+l) + 1.
2.4 Recurrence relat10ns w1tn var1aDle coerr1C1cncs

This is a very complicated topic. Here we shall look at

just one equation, the particularly simple linear first-order
relation

a n +l s(n) - ant(n) = u(n).

On dividing through by sen) this becomes

a n + l - an g(n) = fen) (35)

We want to express (35) in a form that we know haw to deal with.

Suppose first that fen) = O. Then

o , (36)

where g(n) is still a variable coefficient. However, if (36) is

divided by II ~=l g (k), the result is

l n
a n + l / II k-l g (k) ] - n - lg(k)
[ an;t! k=l ' ] 0, (37)

and this is a homogeneous equation with constant coefficients in

the variable

n-l
a n ;11 k=l g (k) • (38)

The characteristic equation of (37) is linear, ' and the solutio

is therefore an arbitrary constant A. The change of variable has
now to be put into effect 'throughout (35). This results in

It can be shown that the solution of (39) is

t;n-l k
A + ~k:l [f(k)/ITi=l g(i)]

in terms of variable (38). Hence

1I~:i g(k) [A + r~:i {f(k)/IT~=l g(i) n. (40)

 29

Examples:

1. a n + l - ann 1. Here g(n)=n, f(n)=l, and we have

an = (n-l): [A + I~:i 11k:].

2. n(n+l), with al=l.

2
l
a n +l - ( n+n ) n+nl
<;>n-l k+lnk ri+l]2]
Gk=l -X-t"f=l l-r-

n
2 [A ~n-l
+ l.k=l ¥ I (k+l) 2J

= n2[A ~n-l
+ l.k=l k(k+l) ]
2
n [A
~n-l
+ l.k=l (~- k;l)]
2
n [A + n~l].
2
Hence = n A + n(n-l), and use of al=l gives A=l.
a
n.
The solution: a = n 2 + n(n-l) = n(2n-l).
n

2.5 Effect of balancing on binary search trees

Let a binary search tree contain N nodes, and let n be th~

i
number of nodes located on level i. Originally the N records could
have been entered in N: different sequences, giving rise to N:
binary trees (which need not all be distinct). The different
possibilities for three records, with keys 1,2,3, are shown in
Fig. 10.

123: 132: 213: '231: 312: 321:

®
/,(J) ri~
Figure 10
For a given tree the total number of comparisons required to
find all N records divided by N is the expected number of comparison~
required to find an arbitrary record in the tree. However, since
there are N: trees, these expected numbers for particular trees have
 30

to be averaged out over the N: trees for the overall expected

number of comparisons. D8note this quantity by C , and denote N
by CN' the expected number of comparisons in a balanced binary
search tree. We have

i 1 2 3 4 5
c. 1 3/2 17/9 53/24 149/60
C,
~
, 1 3/2 5/3 2 11/5 (41)
~
ratio 1 1 1.13 1.10 1.13

Derivation of C
N is easy:

•
C
N = ~ l~=o (i+1)n i (M l1og 2 NJ ).

where, by definition of a balanced binary tree,

2i for i < M, and ~= N -

M
(2 -1).

Hence

N = N~(M+1)
C' (N+1-2M)+~ \ ~-l (i+1) 2 i
N L ~=O

= (M+I) (l+~) _ (M+I)2

M
+ (M-I) 2M+I
N N N

= (M+I) (l+~) 2M+I +!

N
N -N-

= M, for large N. (42)

There are three stages to the determination of CN' namely the

setting up of a recurrence equation, the solution of this recurrenc
and the simplification of the solution by means of an approximatior
The first of these is the most difficult.
When a search tree contains N-l nodes, the number of positionE
that can be occupied by an N-th node on level i is

(i<O) ,

as illustrated by Fig. 11. Moreover, if we look at the entire tree

 ·H.

there are precisely N locations at which the N-th node can be

placed: each occupied position suspends 2 arcs, and each of N-2
\odes is at the end of some arc (the N-I nodes except the root);
hence the number of locations available for the new node is
2(N-l)-(N-2) = N. On the assumption that the new node is equall~

likely to occupy anyone of these N possible locations, the

probability that the new node will go into level i is

With the new node added there are now N-l nodes for which
the expected number of comparisons is C~l' and the added node
HI
for which it is ~(2ni_l - ni' summed over all levels. Hence

Then

,N-l
[.i=l (i+l) (2n i _ l - nil
,N-l . N-l (' ' ) ,N-I ,
Li=l ~n.
.~-
I + 2 }:N-l
~=~-
'-I ~n,1- l-~n.
. In, 1 + }: 1- 1 -[.·-ln~.
1-

(43)

i=O

i=l
,,
,,
I
,,
, , ;' ,
, ,, '\ i=2

, ,, ,,
I ,
, I \
...

Figure 11
 32

The reason for ..

spl~tt~ng up t h e 'i'2' . t 0 pro d uce 'i'N-l
~ ~ni-l ~s ~i=l
(.~ni-l

in ), which becomes (I~:~ n i - (N-l)n N_ l ), and, since n N_ l = 6,

i
ultimately becomes 'i'~-2 n N-l. Also 'i'N-l n = ~-2 n. = N-l.
~i=O i £i=l i-l i=O ~
Hence (43) becomes

(N-l)C N_ l + (N-1) + I~:~ni + (N-l) - I~:~ni

(N-l)C _ + 2(N-l) + no - n _
N l N l
(N-l)C _ .+ 2(N-l) + 1,
N l
and, after some rearrangement,

1 2
C _ + N 1
C = (l-iF) - N
-2
N N l .

This put into form (3£l becomes

1 2. 1
CN+ 1 = (1 - TN+lT 2 ) CN + N+l - (N+T) 2. (44)

Now, in accordance with (40) , equation (44) has the solution

.
N-1
CN = II k=l [ 1 '-
(k~l) 2J[ A + rNk=l- l { 2k+1 k
(k+1) dIIi=l [1 - chI) 2]} J
= nNk=2 [1 - -+-J[A + IN
k=2
{ 2k,..1 / rrk
-p- i=2 [1 - }rJ}].
n+l
It can be shown that rr ~=2 (1-~2) 211
Hence

C = (N+l) [A + IN
N 2N
(2k-l) (2k
k=2 -p- m )J
= (~~l) [A + L~=2 ~i~~l~)]' N~ 2.

In now remains to use C 2 = 3/2 to establish that A=l. Then

2 (2k-l)
k(k+l)
J
 33

.. (N+l)
2N
[1 + L
N
k=2
6
k+l K
2
lJ
~~1)lL~=3~+ N~l ]

(~~1) [ 4H N - 4 - 2 + N~l ]
1
2 (l+&)H N - 3, (45)

where H is the harmonic number H 1 + !2 + 'j'-t···+

1 1
N N W

Finally it remains to simplify (45) by removing the summation

that is implicit in H • There exists the expansion
N

111
loge N + 0.577216 + 2N - 12N 2 + l20N~ -

Hence, for large N,

(46)

Thus,

1. 39.

As (41) shows, the ratio is even smaller for small N. Our

conclusion is that one need not be greatly concerned with the lack
of balance in a binary search tree, or, expressed more precisely,
increase in search costs due to lack· of balance has to be weighed
against the cost of keeping the search tree balanced. However,
one should keep in mind that in the worst case, when the height
of the binary search tree that holds the N records is N-l, the
expected number of probes required to retrieve an item is ~(N+l) _.
N l
the probability that the tree has height N-l is 2 - /N:.

2.6 Analysis of search in AVL trees

Recurrence relation (28) gives an' the n~~ber of nodes in the

most skewed AVL tree of height n:
The particular solution we look for is of the form dn, and we do
in fact obtain

K (p)
( 3+/S)
n 5+15 n.

Since only the particular solution depends on n we can make a

further approximation, taking just the particular solution for
the total solution. Thus

K '" (3+/S)n (52)

n 5 + Is

,The n in (52) is height of the AVL tree. We want to express

K in terms of an = N, the number of nodes in this AVL tree.
n
Going back to the solution of (28), we see that for large n

log an '" n log (1;/5),

giving

3+/5) (1+/5)
KN '" logN ( 5+/5 flog - 2 - (53)

Using base 2 logarithms in (53) we obtain

(c. f. C'
N

This is a very encouraging result, .particu1arly if we keep in

mind that it pertains to the worst case. Empirical studies show
A
that on the average KN = log2N + 0.25.

In the derivation of (53) a total of four approximations weI

made. Keep in mind that the courage to make approximations is a
sign of mathematical maturity.

2.7 Insertions and deletions in AVL trees

Insertion of a new record in a balanced binary search tree

 37

holding N records is in the worst case an O(N) process in that

the restructuring necessitated by the insertion may change
every parent-successor relationship in the tree. An example of
this is provided by Fig. 12.

Figure 12

In an AVL tree, on the other hand, restoration of height

balance after an insertion is a local phenomenon confined to a
path from root to a terminal node, and, since the height of an
AVL tree is O(log N), insertion is an O(log N) process. In what
follows it will be assumed that each node in the tree.carries a
"balance flag", which is 0 if the height of the left subtree
of the node exceeds that if the right subtree, ($I 1'f the right
subtree has greater height, andeif both subtrees are of the
same height. All terminal nodes carry balance flage.
If height balance is violated by the insertion of a new
(terminal) node, it can be restored by the single application of
one of two rotation operations defined below. On the path from
the root of the tree to the point of insertion of the new node
consider a subpath (A,B,C), where A is the root of a subtree
that does not have the AVL propert¥, but the subtree rooted at
B does have this property. The cause for the lack of balance is
the newly inserted node, and to restore balance it would suffice
to shift just this one node in such a way that its level number
is decreased. However, we also have to maintain the search tree
property, which complicates matters somewhat, and we find that
conservation of the search tree property requires that nodes A,B,
C, be rearranged, and ,that the subtrees suspended from these
nodes (if there are any) be shifted around as well. There are
four cases, corresponding to the four forms that subpath (A,B,C:
can take. In tFO of the cases we speak of a single rotation
 38

of nodes A, B, C, in the other two of a double rotation of these

nodes. Fig. 13 shows the rotations (a and b are single rotations,
c and d are double rotat':.ons), and Fig.14 shows the rearrangement
of the subtrees. Figs. 15 and 16 show two examples: they represeI
respectively, cases c and a.

1\

d:

Figure 13
 39

C1

C1 B

y 6

B y

B y

Figure 14
 40

Figure 15

I
I

CD
Figure 16

The following restructuring process takes place after an

insertion: For every arc on the path from root to newly inserte!d
node, moving upward toward the root, perform the action indicate!d
by the table of Fig. 17. Note that in the instances in which
rotation is required the flags of C and B will have been a1teredl
before A is reached. These flags may then have to be reset. T~le

flag settings follow the scheme of Fig. lB.

Deletion differs from insertion in that deletion can take
place anywhere in the tree, i.e., the deleted node may be internla
One way of solving this problem is to initiate an inorder traver'S
of the right subtree of the node that ,is to be deleted, and to 5:11
 41

Balance flag orientation Orientation Action

nf tail of arc of arc of arc examined
before this arc

e R set flag ~

e L set flag 0
0 R set flag e ; stop
0 L L a: rotate; stop
0 L R c: d.rotate; stop
(:)) R L d: d.rotate; stop
(:)) R R b: rotate; stop
(:)) L set flag e; stop

Figure 17

Cases a,b: set flags of A,B to e leave flag of C unchanged

Case c: setting of flag of C new settings of flags of

A B C
e e e e
0 IS> e e
IS> e 0 e
Case d: setting of flag of C new settings of flags of
A B C

e e e e
0 e ~ e
s 0 e e
Figure 18

the key associated with a node in this traversal sequence into its
predecessor node in terms of the inorder sequence. Ultimately the key
associated with a terminal node is so shifted, and this terminal node
becomes vacant. Now a procedure analogous to that for insertion can bE
used to restore balance in the tree. No more than O(log N) nodes are
examined, i.e., deletion is also an O(log N) process.
 42

3. GRAPHS AND K-TREES

3.1 Representation of digraphs by K-trees

Consider the digraph of Fig. 19. For each node, let us

generate a tree consisting of the node as root and the arcs
originating from this node. The result is Fig. 20. There
trees are called atomic K-trees. and the atomic K-tree having
node x as root is the atomic K-tree of noce x. The following
algorithm merges atomic K-trees into one or more composite
K-tree(s). For our example the result is the K-tree shown in
Fig. 21. Since we are dealing here with both digraphs and
K-trees representing digraphs, a distinction must be ,made
between nodes of the original digraph and nodes in the K-tree
representation. We shall use the terms D-node and K-node to
differentiate between the two.

Figure 19

~ ~ JR ep ~ JR ~
~,~ ~ ,~ ~ ~ ~ ~ ~'~ ~'~ ~ ~ ~ ~
Figure 20
 43

Figure 21

ALGORITHM. The input to the algorithm is a list of atomic

K-trees T=t ,t , ..• ,t , where t is the atomic K-tree of node i
1 2 n i
(for some D-node j there may not exist a t because no arcs
j
originate from j in the digraph). The output consists of lists
K and K' of composite K-trees. Lists T' ,K, and K' are assumed
to be initially empty.

Comment determine D-nodes with zero indegree;

for i:=l to n do idnonzero[i]:= false;
for i:=l to n do
if t. exists then
1. --
begin for all terminal nodes of t do
i
begin y:=labe1 of terminal node;
idnonzero [i J:=true
end
~;
for i:=l to n do
if idnonzero~ ~t. exists then transfer tJ.' from T to T
- 1.

~ T not empty do
 44

begin comment: tree building phase;

k:=any atomic K-tree still in T;
delete this atomic K-tree from T;
for all terminal nodes in k while k traversed under preorder ~
begin y:= label of terminal node;
if t is in T' then
y
begin replace terminal node y by atomic K-tree t y ;
delete tyfrom T'
end
end;
add k to list K
end tree building phase;
while T' not empty do
t
begin comment: merge atomic K-trees that may still be in T ;

k:=any atomic K-tree still in T ' ;

delete this atomic K-tree from T ' ;
for all terminal nodes in k while k traversed under preorder do
begin y:=label of terminal node;
TO_
-if t y is in . then
-
begin replace terminal node y by atomic K-tree t ;
Y
delete t from T
y
end
end;
add K-tree k to list K'

Any set of trees that contain precisely the arcs of a

digraph D is a K-tree representation of D, but it helps to
narrow this definition somewhat. Let a list of K-trees k ,k , ••• ,
l 2
k represent D. This list is a depth-first representation of D
u
iff the following holds for every D-node s from which arcs
originate: there is a unique internal K-node s, and, if this
internal K-node is in K-tree k , then there is no terminal node
i
s in any of k ,k , ••. ,k _ , and in k no terminal node s
l 2 i l i
precedes the internal. s in the preorder sense. If, moreover, u
is equal to the cardinality of the node base of D, then the depth-
first K-tree representation is minimal.
The node base of a digraph comprises all nodes with zero
 45

indegree, and one node form each nontrivial strong component that
has zero indegree as a whole. It is easy to see that the roots of
the K-trees in a minimal representation constitute a node base.
The output of the algorithm above consists of list K, followed
by list K',~ where either ~f the lists may be empty, and this
output has the depth-first property. Moreover, if K' contains no
more than one K-tree, there is minimality. If K' co~~ains more
than one K-tree, then a determination has to be made 'Jf whether
or not the roots of the K-trees belong, as D-nodes, to strong
components of zero indegree. If they do not, then the K-trees
rooted at these nodes can be absorbed by other members of K', and
a minimal representation results. More detail of this at the
start of Section 3.3.

The digraph of Fig. 22 provides an example of a digraph

for which our algorithm builds a representation consisting of two
K-trees, although a representation in terms of a ·single K-tree
is possible.

Figure 22

For many algorithms based on K-trees it is not necessary

to go through this second phase to ensure that a minimal represen-
tation is obtained. For an ayclic digraph the basic algorithm
produces a minimal representation. .For an acyclic digraph it can
be shown that in a depth-first K-tr¢e representation all arcs
belonging to a given strong compone$t of the digraph define a
connected substructure of a single ~-tree of that representation.
 a corollary of the second result we have that a digraph is
c.elic iff a K-tree in its depth-first representation contains a
path of the form (a, ••• ,a).
The primary advantage of the K-tree representation of a
digraph is that is contains precisely the arcs of the original
digraph, but in such a way that much of the structure of the
digraph is still explicitly there. This contrasts with a direct
representation of a digraph by a linked storage structure,
which retains all the structural information, but is awkward to
operate on, and the representation of the digraph by its
adjacency matrix in which the structure becomes totally
obscured. Adjacency lists conserve no ~ore structure than does
the adjacency matrix; the compression of rows of a matrix
into adjacency lists is a standard technique for the represen-
tation of sparse matrices in general.

3.2 Depth-first search algorithms and K-trees

In this section the utility of K-trees will be demonstrated

by means of algorithms for the critical path analysis of a
scheduling network. All the algorithms will have time complexity
O(max(m,n», where m is the number of arcs and n is the number of
nodes. For any reasonable digraph, m is at least n/2, and
O(max(m,n» becomes O(m). It will be seen that some of the
algorithms are similar to recursive algorithms known as depth-
first search algorithms, which have been extensively described in
the literature. However, there a~e significant differences.
First, the K-tree approach permits heavy use to be made of the
standard tree traversal disciplines, which are well known and weI]
understood. Second. because of the dependence on tree traversals,
algorithms can be written non-recursively in a natural manner.
Third, the reliance on tree traversals permits one to regard the
K-tree and a small number of operations on the K-tree as an
abstract data type, a point that will be taken up again in
in Chapter 4.
 47

A scheduling network is a 6-tuple <E, e ' e , A, W, w> ,

s t
where E is a set of nodes (for convenience we put E = {l,2, ••. ,n}
e is the only node with zero indegree, e is the only node with
s t
zero outdegree, A is the set of arcs, W is a set of weights,
w is a function on A into W that associates the weights with the
arcs, and the digraph D = <E,A) is acyclic. Then lEI = n, and
we set IAI = m. Members of E, A, and Ware called, respectively,
events, activities, and durations. The weight associated with a
arc <x,y> will be denoted by w!.X ,YJ. Events e and e are called
s t
start and termination, respectively. <
If, for every x, y> E A,
the relation x< y holds, then the activities are in topological
order, and
s
= 1 and e t = n. With each node y E E there are
e
associated two times, the earliest event time eet[yJ, and the
latest event time let[yJ. Assuming topological order, they are
defined as follows:

eet[l] 0;
eet[yJ maxx<y(eet[x J + w[x,yJ), y 'I- 1;

&et[n] eet [n J;
let[yJ miny>x (let [x J - w[x,yJ) , y 'I- n.

With activities in topological order, the earliest event times

can be evaluated for all nodes in the order l,2, ••• ,n, and the
latest event times in the order n, n-l, ••• ,l. With each activity
<x,y) £ A there is associated a time, called the float of the
activity, defined

float[x,yJ = let[yJ - eet[xJ - w[x,yJ.

An activity with zero float is critical, and a path (e "" ..• ,e )

s t
consisting entirely of critical activities is a critical path.
The purpose of critical path analysis is to evaluate the floats,
and hence identify critical paths.
Before one begins with the critical path analysis proper,
the absence of certain anomalies has to be established. The
anomalies are: (1) the presence of cycles in the network; the
presence of "holes" due to (2) more than one node in the network
having zero outdcgree, and (3) more than one node having zero
indegrec.
Anomaly (3) exists iff there is more than one K-tree in
list K when the tree-building algorithm of Section 3.1 stops.
Tests for the other two anomalies can be easily built into the
tree-building algorithm. Here, however, we shall put the tests
for anomalies (1) and (2) into our next algorithm, which finds
a topological ordering of the nodes of an acyclic digraph.
Although the depth-first K-tree representation of a scheduling
network consists of a single K-tree, topological order can be
imposed on the nodes of any acyclic digraph. For this reason the
input to the algorithm will be permitted to consist of a depth-
first representation containing more than one K-tree.

ALGORITHM. An O(m) nonrecursive depth-first K-tree algorithm for

the topological ordering of nodes in an acyclic digraph. When
the algorithm stops, topno[l], ... , topno[n] contain the labels
that have been given to D-nodes 1, ... ,n, respectively, to induce
topological order.

for i:=l to n do topno[i]:=C:

j:=l: cycles:=~:
fQL all K-trees in list K in right-to-left order do
for all K-nodes while K-tree traversed in R(postorder) £Q.
begin
y:=label of K~node:

if K-node y is internal ~ ~ topno[y]:;j: j:=j+l end

~ if topno[y]10 then cycles:=true
end:
comment: cycles = ~ implies anomaly (1);
if j=n ~ topno[y]:=n
~ begin comment: anomaly (2) exists;
.f!;rr i :=1 to n do
if topno[i]=O. ~ begin topno[i]:=j; j:=j+l end
 Of the n D-nodes of a scheduling network, n-l should have
nonzero outdcqrce. The D-nodes with nonzero outdegree are in
one-one corrc9!>ondence with internal K-nodcs, and j is incremented
each time one of the latter is processed. Hence jln after the
traversal has been completed implies the existence of fewer than
n-l O-nodes with nonzero outdegree, i.e., more than one O-node
with zero outdegree. The latter are identified by searching
through topno for elevents that are still zero.
The demonstration that the algorithm detects the presence
of cycles is only slightly more complicated. The alqorithm subjects
the K-trees of list K=k l ,k , .•. ,Yu to reverse postorder traversal
2
in the order ku,ku_l, .•• ,k • Under this strategy all terminal
l
K-nodes labeled yare processed before the one internal K-node
y is processed, with a single exception: if there exists a
path (y, ••• ,y) in a K-tree, the terminal K-node y on this path
is processed after the internal K-node y has already been
processed. Hence, in terms of our algorithm, topno[y]~O when a
terminal K-node is being processed implies the existence of path
(y, ••• ,y), i.e., it implies cyclicity of the digraph.
Actually there is no need to have the events·topologically
ordered by a separate algorithm. For critical path analysis it
suffices to sweep through the single K-tree-representing the
scheduling network just twice: a reverse postorder traversal gives
earliest event times; a sUbsequent postorder traversal gives
latest event times and floats.

ALGORITHM. A depth-first K-tree algorithm for critical path

analysis. It is assumed that the network contains no anomalies.
Earliest and latest event times for the n events are stored in
arrays eet and let. Although wand float are indicated as two
dimensional arrays, they are actually "arc d~ta". Every K-node
except the root of the K-tree is the head of an arc: the K-node
labeled y whose parent is K-node x can therefore be made to
represent arc <x,y). This means that w[x,y] and float[x,y] can
in practice be represented by appropriate fields in a record that
we associate with arc'<x,y> by associating it with this K-node y.
 50

~ i:=l .tQ. n QQ.. eet[i]:=O;

for all K-nodes except the root while K-tree traversed
under R(postorder) do
begin y:=label of K-node;
x = label of parent of y;
eet[y]:= max(eet[y], eet[x]+w[x,y])
end;
comment: y is still the label of the K-node reached last under
R{postorder) traversal, and no let that will be computed
can exceed eet[y];
ful: i:=l :to. n .do...let[i]:= eet(y];
for all K-nodes except the root ~ K-tree traversed under
postorder ..llQ
begin y:=label of K-node;
X:= label of parent of y;
let[x]:=min(let[x], let[y]-w[x,y]);
floattx,y]:=let[y]-eet[x]-w[x,y]

In other critical path algorithms the,eet of a node y is

computed in one go, which requires' rather costly bookkeeping in
that one has to access at this' time the tails of all arcs that
terminate at y. In our algorithm the K-tree is. itself the
bookkepping device. Suppose there are j arcs with D-node y as
their head. Then, in the K-tree, there are j K-nodes labeled
y, and the labels of the parent K-nodes of these j nodes
identify the tails (in terms of the network) of the j arcs.
We begin with eet[y] set to zero. Then, whenever one of the
j K-nodes labeled y is visited during the tree traversal, the
sum of the eet of the tail of the arc and the duration associated
with the arc is compared with the current value of eet[y], and
the larger of the two becomes the new value of eet[y]. The
computation of the eet(y1 by successive adjustments spread out
in time is similar to the method used by Dijkstra in his
algorithm for the shortest paths from a single source in a
digraph. Computation of latest event times is precisely analogous
In a proof of the algorithm the crucial step is to show that
whenever one of the K-nodes labeled y is visited, the eet of its
parent be already established, and it is easy to show that this
 51

holds true in a depth-first K-tree traversed under reverse

postorder. By symmetry it ~hen follows that latest event times
are also computed correctly. Finally, to justify the initializ-
ation of all elements of let to the value of eet[y] it has to be
shown that the K-node processed last under reverse postorder
carries the label of D-node e "
t
If one is interested merely in the determination of critical
paths, then there is no need to apply the algorithm in its
entirety. The earliest event time of a node is the length of
the longest path form e to this node. In particular, ee~et]
s
is the length of the longest path from e to e • All longest
s t
paths form e to e are critical, and only these paths.
s t

ALGORITHM. Given a depth-first K-tree o~ an acyclic digraph D

that contains the source as its root, and all nodes reachable
~ the source. The algorithm computes in array length the
lengths of longest paths form the source to all other D-nodes
reachable from the source, and specifies the longest paths in
array before. One longest path =rom the source to node i is
["~,.,,rc.
defined, in reverse order, by i, before [i] , before [i ]] ....
A
If before[j]=O when the algorithm stops, then j is the source,
or it is a node that is not reachable in D fro~ ,the source.

for.i :=1 !£ n do length[ i 1:=before[iJ :=0;

for all K-nodes except the root while K-tree traversed
under R(postorder) do
beqin y:=label of K-node;
x:=label of parent of y;
newlength: =length LX J+ W [x, y] ;
!! newlength) lengthLY] then
begin length(y]:=newlength;
J
before[y :=x
end
end;

As given above, the algorithm determines just one longest

path from the start node to any other node reachable from it.
 52

To generalize the algorithm, one has to make before[y] a list

of node lab0ls, and refine the comparison step to the following:

l i newlength;> length[y] ~
begin lengthly]:=newlength;
make beforety] an empty list;
add x to list before [y ]
end
else if newlength=length(y] then add x to list before[yJ;

If all length (i) are initialized to a number greater than

any feasible path length, length[root] is then set to zero, and
greater than (» replaced by less than «), the algorithm
becomes one for shortest paths in an ac~clic digraph. Fig. 23
shows the K-tree of a acylic digraph with arc lengths as shown.
The algorithm would compute the length of the shortest path
(1, ••• ,5) as 5 instead of the correct 4.
Although our topological ordering algorithm detects
cyclicity and either the tree building algorithm or the critical
path algorithm can be modified to do so as' well,' there still
remains the task of identifying all arcs that lie on cycles.
Strong component analysis seems to provide the fastest means
of identifying such arcs: an arc lies on a cycle iff it belongs
to a strong component of the digraph. The algorithm given below
is therefore a strong component algorithm that identifies ~

that lie on cycles. It is an easy matter to modify it so that

it defines strong components in terms of nodes: delete the
statement that effects output of the arcs, and output the node
labels as they are popped up from the stack. The labels that are
.popped up in the one pop-up sequence define a strong component.

ALGORITHM. A non-recursive strong component algorithm for a

depth-first K-tree representation of a digraph. The output
consists of arcs that belong to strong components (if there are
any such arcs). Each D-node is pushed down exactly once. Each
arc is traversed once under preorder, once under postorder,
and the traversals are intertwined. The first time "advance 'to
next K-node under preorder" is executed, the "advance" is to
 53

Figure 23
 54

the root of the K-tree. The K-node that is the first to be

processed each time the -repeat ... until alldone loop is entered
is the one that was the last to be processed in the preorder
phase of the algorithm.

for i:=l to n do begin ordinal(iJ:=O: root[iJ:=true end:

count:=O:
for all K-trees in left-to-right order do
begin rootdone:=false:
repeat terminal:=alldone:=false:
repeat advance to next K-node under preorder:
y:-1abel of K-node:
j ! ordina1(y]=O ~
~ ordinal[y1:= count:= count+1:
push down y
~
if K-node terminal tllilll termina1:=~

until terminal:
repeat advance to next K-node under postorder;
jL K-node is root of K-tree ~
begin alldone:= rootdone:= ~:

pop up labels until stack empty

~
else
begin y:=label of K-node:
..i!.. y on stack ~
begin x:=label of parent of y:
i f r~ot[y}- (ordinal y >ordinal(x]) ~
pop up labels until y has been
popped up
else begin output<x,y>:
if ordinal[yJ(ordinal(x] then
begin ordinal[x]:=ordinal[y);
root[x):=~
end
end
end;
if next K-node in postorder sequence not

vet visited
 55

under preorder ~ alldone:=true

~
until alldone
until rootdone
end;

It was stated earlier that in a depth-first K-tree represen-

tation all arcs that belong to a given strong component of the
digraph define a connected substructure of a single K-tree of
that representation. This connected substructure is itself a
tree. Denote it by sl , and suppose that its root is labeled a.
In the preorder traversal phase ordinal numbers are assigned to
D-nodes in an increasing sequence. Hence the ordinal assignment
made to any D-node in the same strong component as a is initially
greater than that made to a. If S' represents a nontrivial
strong component, then it must contain a path (a, ••• ,b,a). In
the postorder phase tne ordinal assignment that was made to a is
propagated upward along this path using the criterion that if the
current ordinal of a node q is smaller than that.of its parent p,
then the ordinal assignment of D-node p is changed to that of q.
D-node a is the only node in sl whose ordinal assignment does
not get changes this way. Moreover, on reaching root node a of
S/, the ordinal associated with its parent is smaller than that
associated with a (unless a is the root of the K-tree and hence
has no parent). Thus the root of s is identified by the
double criterion the (i) its ordinal assignment has not been
manged (Boolean array root is used to detect this), and (ii) its
parent carry a smaller ordinal assignment that it itself carries.
When the root of S has been identified all node labels up
to and including a are porped up from the stack, and they define
S. Here, although our concern is with the arcs that make up S' ,
the stack is still needed. Suppose in the postorder phase arc
<c,a) is being examined, and label a is not on the stack. This
means that <c,a) cannot belong to a strong component. Output of
this arc is therefore'prevented, and so is the upward propagation
of the ordinal associated with a, which might otherwise take
place. Note that the output of the arcs of S may be interspersed
with the output of arcs belonging to other strong components,
i.e., arcs that define the one strong component need not be
written out in a contig.lOuS sequence.
The K-tree of Fig. 24 shows that both of the conditions
given above are needed to identify a node as the root of a strong
component. Without condition (i) node v would be interpreted as
the root of a strong component. Without condition (ii), terminal
K-node s would trigger the popping up of nodes u,t,s from the
stack. Consequently node v, which belongs to the same strong
component, would not be recognized as such.

Figure 24

3.3 Algorithms that change the structure of K~trees

Our basic K-tree building algorithm changes the structure·of
a K~tree. For the construction of K-trees by this algorithm an
operation is required that takes an atomic K-tree and grafts it
on at a terminal node of the composite K-tree. Further, if we
were required to produce a minimal K-tree representation of a
digraph, the K-trees in list K ' after the basic algorithm stops
would be partitioned into a set A of K-trees whose roots belong,
as D-nodes, to strong components of zero indegree, and set B of
K-trees \o?hose roots do not define such strong componen~s. Then
the K-trees of set B would be completly absorbed into those of
set A by traversing the latter, and at each terminal node
checking whether an internal node with the same label exists
within a K-tree belonging to B. If so, the entire subtree
rooted at the internal node would be pruned away from its present
 57

location and grafted on at the terminal node that has been

reached in the traversal of the K-tree belonging to A.
We next have a K-tree algorithm for the simple cycles
of a digraph. This is not a particularly efficient algorithm,
and it is included here only as another illustration of pruning
and grafting. The best input data to this algorithm is a set
of K-trees each of which represents one of the nontrivial strong
components of the digraph. The following procedure is applied
to every K-tree in this set.

push down root;

far all K-nodes except root while K-tree traversed under preorder do
hesin y:=label of K-node;
x:=label of parent of y;
pop up from stack all nodes up to but not including x
i f y is internal then push down y
~ if y not on stack then
~ prune subtree suspended from internal K-node
y (if it exists)
and graft it on at the terminal node y being
processed;
push down y which has been marked
fm2.
~ if neither y nor any node below it in the stack
carries a marker
then output cycle defined by y and the nodes above
it in the stack, and the terminal node y
being proc::essed

Consider now the scheduling of a job on three machines,

where some time is required on each of the machines, which may
be used in any order. The changeovers from machine to machine
differ in cost, and this may make some orders in which the
machines are used more expensive than others. The costs are
given by matrix C below, where C .. is the cost of changing over
from machine i to machine j, and1~ . is the initial tooling-up
oJ
cost for machine j •
 58
o 41 32 35]
1 - 3 8
2 4 9
[
3 98-
1 2 3

The exhaustive enumeration of Fig. 25 shows that the best

sequence is 2-1-3, with cost 44. The method of backtracking is
used to derive the best sequence without an enumeration of every
possibi1ty. Under backtracking the tree of Fig. 25 is built in
stages, arid, hopefully, a solution can be established before the
entire tree has been constructed.

53 57 44 50 47 47

Fig. 25

There are several basic backtracking schemes, which differ

in the way the node is selected from which the tree is to be
extended. Here we consider o~ly one such strategy because its
implementation presents the most interesting data structuring
problems. This is the method of best cost in which one branches
from the node that has the currently lowest cost value. Costs
are evaluated for all successors of the root of the tree. There-
after branching takes place from the node that has the lowest
cost value associated with it.

ALGORITHM. Best cost backtracking algorithm for the n-machine

job scheduling problem. Priority queue pqueue is used to find
the node of lowest cost value. When the algorithm halts an optimal
 59
solution is given by the path in K from its root to the node
pointed to by P.

L:="';
y:=start-up node;
set cost of start-up node to zero;
K:=atomic K-tree of y;
done:-false;
repeat
fill: all successors of y do
~ x:=node being processed;
cost:=(cost of y) + (cost of yx);
i f cost < L tbgn
if x not on level n then
enter in pqueue a record consisting of cost and of a
pointer to node x in K, using the value of cost to
determine the position of the record in pqueue
else begin L:~cost;

P:=pointer to terminal node x

end:
~ pqueue empty thgn done:=tLue
>'
~ if (lowest cost value in pqueue) = L ~ done:=tr~

else
begin extract lowest cost record from pqueue:
use it to gain access to a node in K:
y:=the node accessed in K:
attach atomic K-tree to y in K

~
until done:

Two remarks. First, the same atomic K-tree may be attached

in more than one place at the same time. Second, the storage
requirements for the tree may become very high, which suggests
that a procedure should be built into the program that prunes
away parts of the tree for which there is no further need.
 60

3.4 K-trees of undirected graphs

An edge {a,b} of an undirected graph may be represented by

the pair of arcs <a,b>and <b,a>. Fig. 26 shows a graph and the
K-tree of the arcs obtained when edges are replaced by arc pairs
in this manner. However, since one of the arcs then invariably
implies the other, there is redundancy. A systematic way should
therefore be sought for selecting just one of the arcs in the pair.

Figure 26

One approach suggests itself immediately: for the

representative of {a,b} take that ordered pair (arc) of a and b
in which the first coordinate is smaller than the second. Under
this scheme, if the K-tree of the arcs.is next interpreted as
representing a digraph, the digraph that it represents has to
be acyclic because it is topologically ordered. It is debatable
whether this is the best appr~ach•. Applying it to the graph of
Fig. 26 we obtain the representation shown in Fig. 27, and this
representation consists of two K-trees. It may be argued that
an increase in the number of constituents of a representation
(K-trees) cannot be regarded as a simplification.

Figure 27
 61

We therefore try a different approach. For each node x in

the graph construct an atomic K-tree consisting of x as root and
nodes adjacent to x as leaves. Then apply the tree-building
algorithrnof Section 3.1. For a connected graph the result must
be a single tree (because all arcs that belong to the same strong
component must be in the same K-tree). Fig. 26 provides an
example of the approach to this point. Next subject the K-tree
to the following "clean-up" procedure.

for all terminal nodes while K-tree traversed under preorder do

begin x:=label of node;
y:=label of parent of Xi
z:=label of parent of Yi
i f x=z then delete <Y,}(;> from K-tree
else delete <x,y> from K-tree

Fig. 28 shows a K-tree before and after application of this

procedure.

Figure 28

This representation has the interesting property that it

holds within itself in easily accessible f~ the fundamental
circuits of the graph. They are all paths of form (a, •.. ,a) in
the K~tree. For the example of Fig. 28 they are (1,2,3,1),
(1,2,3,4,1), (2,3,4,2).
 62

3.5 K-trees and K-formulas

A K-tree can be represented by a K-formula, and the latter

is very easily constructed: carry out a preorder traversal of
the K-tree~ listing nodes in the order they are encountered; in
the case of an internal node precede the node label by as many
K-operators (stars) as there are arcs originating from this node.
The K-tree of Fig. 21 yields

**1**23***813***73***434*5**63758 (54)

Such a representation is very convenient if it is to be stored

in secondary memory or transmitted between the nodes of a
computer network. The utility of the K-formular representation
increases if one can avoid too many translations between the
representations, and one would therefore wish occasionally to
perform operations directly on a K-formula. Operations that
induce structural changes do not lend themselves well to this,
but the operations associated with depth-first search can be
easily expressed in terms of K-formulas.
Consider in the K-tree of Fig. 21 internal node 4. Suppose
one were required to find its right neighbour. It can be seen
easily enough in Fig. 21 that this neighbour is terminal node 5,
but its identification in the K-formula is not all that obvious.
One has to skip across the representation of the subtree rooted
at 4, namely

***434*5**~37

and take the next symbol.

The representation of a subtree of a K-tree is a K-formula
in its own right, but how does one identify this K-formula?
A test derives from a definition of K-formulas as algebraic
objects:
a. A node symbol. is a K-formula.
b. If a and Bare K-formulas, then *aB is a k-formula.
From this it follows that string sls2, •. si ..• sm is a K-formula
 63

iff, lettin'.! 111 and lei denote rCl;p<,ctivcly the number of node
symbols and of K-opprators in sl ••• si' the following holds:

< i:=1,2, ••• ,m-l

( 55)

K-formula (54) contains 33 symbols. The storage requirements

can be reduced somewhat if one introduces a bit vector of 33
elements in which an entry is 0 if the carresponcing symbol in
the K-formlua is a K-operator and 1 if it is a node symbol.
Another convenient representation, which does not, however,
reduce storage requirements, is

220 3 0 0 3 030 o 1 2 o o o o (56)

123 813 7 343 4 5 6 3 7 5 8

where above each node symbol is a count of the stars that precede
it.
Reverse postorder is symmetrical to preorder in that
R(past) := C(pre). Hence a K-formula "symmetrical" to (54) can
be produced in a reverse postorder traversal of the K-tree of
Fig. 21:

**18**2***8***75***4*5**673433313 (57)

This beocmes, in analogy to (56),

2 0 2 3 3 o 3 1 2 0 0 o 0 o .0 o o (58)
1 8 2 8 7 5 4 567 3 4 3 3 3 1 3

we give now algorithms for the preorder and postorder

traversals of a K-formuia in representation (56). The two arrays
will be assumed to be named star and riode, respectively, and to
be both of size top. Both algorithms make use of stacks node-
stack and starstack. The greatest depth to which they are used
in either algorithm is equal to the height of the K-tree from
 64

which the K-formula derives. The complexity of either algorithm

is O(top). The preorder algorithm seems redundant in that the
preorder sequence is simply node [1], .node[ 2] , ••. , node [top].
This algorithm would be used only if, during the traversal, it
would be required to identify the parent of the node currently
being processed. In both algorithms, at the time node k is
being processed, the top element in nodestack is the parent of k.

ALGORITHM. Preorder traversal of a K-formula stored under

representation (56).

process node[l];
f.w;: k:=l to n-l do
begin if star[k]tO then begin nodestack ~ node[k];
starstack ~ starCk]

process node[k+l];
i ~ starstack;
i:=i-l;
if ito then starstack ~ i else pop nodestack

The "pop nodestack" indicates that a datum is popped up and

discarded.

ALGORITHM. Postorder traversal of a K-formula stored under

representation (56).

for k :=1 19.. top .do.

if star[k]tO then beain nodestack ~ node[k];
stars tack ~ starCk]
end
else begin process node[k];
moretodo:=~;

ltlhJ.l.e
moretodo /\ nodestacktO do
begin i ~ starstack;
i:=i-l;
i f ito ~ hegin starstack ~ i;
moretodo : =.fsU..ag.
 65

.el.s.e. he.gj.n x + nodestack;

process x
end
end

Reverse postorder traversal is effected by applying the

preorder algorithm to representation (58). Again it should be
noted that (58) is already in reverse postorder, i.e., the
algorithm would be used only if parents of the nodes that are
being processed had to be identified.
Binary trees cannot be represented directly by K-formulas
because'of the left or right orientations associated with their
arcs. Here one shoilld fi'rst convert the binary tree to a general
tree by a reverse Knuth transformation. However, no arc with
right orientation can be suspended form the root of a Knuth
transform. Consequently, before one applies the transformation,
one should introduce a dummy arc in the binary tree. Fig. 29
shows where the dummy arc is added, and Fig. 30 is the K-tree
that results when next the reverse transformation is applied.

Figure 29
 66

Figure 30

A binary search tree is not a good candidate for implemen-

tation as a K-formula because the whole point to using binary
search trees is that is is easy to add new nodes to them. This
is certainly not so for K-formulas. Similarly, a binary tree
functioning as a priority queue is expected to be constantly
changing. Still, there exist binary trees which do not undergo
structural changes. One example is the ancestor tree of a
person in which for every node, the left and right successors
represent, respectively, mother and father of the individual
represented by this node. In some cases only the mother (or
father) might be known, and then only the left (right) successor
is present. In such a binary tree one might be .interested in
determining the parent node of a given node, or the left or
right successor of the node.
An algorithm was given above for the determination of the
parent of a node. Note that this is the parent of a node in
terms of the K-tree, not in terms of the binary tree from which
the K-tree derives. This parent node is still important
because its determination is the first step in the determination
of the parent node in terms of the binary tree.
Consider a node symbol v in a K-formula K. This v is the
leading node symbol of a string embedded in K that is itself a
K-formula representing the subtree rooted at node v in the K-tree
represented by K (if v is terminal, then the embedded K-formula is
merely the symbol v). Denote this embedded K-formula by k .. Now
'f ~
~ we consdier two nodes u and v, where u is the parent of v in
terms of the K-tree represented by K, then we have in K an_
embedded K-formula with leading node symbol v, in which there is
 67

the further embedded K-formula k with leading node symbol v,

i
i.e., we haVe

where kl, ••• ,kare K-formulas, and u is preceded by t K-operators.

t
Now, in terms of the binary tree from which the K-tree
represented by K derives, the par~nt of v is the leading node
of k _ if i> I or ~ if i=l. Node q is found using the
i l
procedure given above, and one then skips k , ••• ,k _ to reach
l i 2
k _ , where k , .•. ,k - are identified as well-formed K-formolas
i l l i 2
by use of (55). A left successor of v exists only if v is
preceded by K-operators, and it is then the next node symbol to
the right of v. A right successor exists only if itt, and it
is the leading node of k + l . Since a well-formed K-formula may
i
be embedded as a proper substring of k to ~he right of symbol v,
i
the only way of finding the right successor of v is again to
identify u, and then skip over k ,· •• ,k .
l i
 68

4. A PHILOSOPHY OF DATA STRUCTURES

~.l Trees as abstract data structures

There is still considerable uncertainty as to what is meant

by abstract data structure , but all seem agreed that the defini-
tion of an abstract data structure has more to do with operations
than with relationships between components of the structure.
~s an example, consider the mathematical object acyclic digraph,
~hich is to be topologically sorted. We can introduce the ~

structure K-tree, about which all that we need to know is that

it comprises certain elements, and that an element may have
successors. We need further an operator that selects the
successors of an element one by one in a particuI~r order (right-
to-left) •
Just as it would be very unusual for a programmer to be
concerned whether a negative integer is represented by its
absolute value and sign, or by the 2's complement of the absolute
value, so he~e consideration of the storaae structuIe or
implementation is largely irrelevant as far as the topological
sort program is concerned. The storage structure could be an
adjacency matrix, a set of arc lists, a general tree, a binary
tree, or even a K-formula. This permits changes to be make to
storage representations without affecting higher level programs.
What complicates matters is that we need a fairly large
number of operations. In addition to operations that provide
access to individual elements in a structure, one needs operations
that associate data records with the elements and permit one to
access the data, and operations that enable structural changes
to be made. The first-observation then is that a set of opera-
tions, including the aCCess operations, has to be predefined, but
how far is one to go? The n nodes of a tree can be processed in
 69

n: ways, and surely we cannot provide this many traversal

procedures. Perhaps the solution here for binary trees is to
predefine just twelve traversals, made up of the three classical
orders, RL-level, RL-down, LR-up, and the converses of these
six.
There are two problems that have to be solved. First, what
happens when a traversal is broken off prematurely? An example:
Suppose a heap that is represented by an explicit binary tree
as in Fig. 8 is to be converted into an array. The binary
tree could be traversed in LR-levelorder, and each node processed
by placing its successors into their appropriate locations in the
array. If the height of the tree is k, then one can terminate
the process after all nodes on level k-l have been processed
because no node on level k can have any successors. Second,
how do we deal with intermeshed traversals? An example of this
is provided by the strong component algoritrun of Section 3.2 •
First suppose that each traversal discipline is implemented by
by providing a start and a ~ operator for the discipline.
Intermeshed traversals can be implemented in a straightforward
manner. The two operators hide from the user the" fact that
there still exists some device that drives the traversal. On
premature termination of the traversal everything has to be
restored to the state that prevailed before the traversal
began. In our case, however, premature termination cannot even
be detected unless complicated scope rules are defined for the
operators, e.g., an operator is assigned to a structure with
this assignment holding just within the block in which it is
made.
Our second solution is to use the following construct,
which was introduced in Section 3.2:
for all K-nodes while K-tree traversed under t do
Premature termination is now easily dealt with: exit from the
loop triggers a clean-up. Intermeshing of traversals appears to
have become next to impossible. Even for a single traversal there
are difficulties. Bot~ the traversal and the processing of the
sequence of nodes are essentially procedures, and we have an
intermeshing of the two. We would provide a composite traversal
package -- the discussion of Section 1.3, particularly Fig. 5,
 70

suggests how this can be done efficiently. Then, however, we

have still to provide the programmer with a facility for defining
traversals additional to the twelve predefined traversals. The
best approach seems to be the use of coroutines. In any case,
the provision of traversals as components of data structures
would bring about changes in the programming language that is to
be used of more than superficial nature.
Another problem relates to traversals and changes to the
structures being traversed. In the algorithm for cycles of
Section 3.3 the K-tree being traversed undergoes structural
changes. We certainly could not in a case like this consider
the implementation of a reverse traversal by pushing down an
entire direct traversal sequence and then popping up from the
stack the reverse sequence. More to the point, what should we
permit? Many traversals are undertaken precisely to change the
structure that is being traversed. Too restrictive an attitude
can therefore not be tolerated. A very permissive approach, on
the other hand, exposes the programmer to dangers. For example,
it would seem wrong to permit a subtree to be pruned away from
the node that is currently being processed, this to be grafted
on at a node that has already been processed, and for the
traversal to resume from this point of attachment. It is this
context that would also give most difficulty with any attempts
at program validation.
Note now that the nodes of a K-tree do not possess identifying
names. They do carry labels, but these labels identify nodes in
the digraph or graph from which the K-tree derives -- the label
is part of the data record associated with a K-node. We introduce
the concept of an active element. During the execution of a
program many different elements in many different structures may be
accessed, but one particular element in one particular structure
is the last element to have been reached. This is the active
element, and it remains active until a different element is
reached subsequently. This permits us to access the data in
the record associated with an element even though the element is
not named. The active element is also useful in indicating an
element at which structural changes are to be undertaken.
Let us now consider pointer data. Pointer variables have
 71

been criticized in much the same way as go to statements. One

concern has been with dangling pointers, i.e., pointers that
continue to point to objects that have ceased to exist. Another
problem may be caused when pointers introduce aliases. Suppose
a file is to be updated, and the old file retained for security
reasons. If there were no additions or deletions, the simplest
approach would be to copy the file and then to traverse the copy
and make changes. The intenced purpose would not be achieved
at all if the "copying" \'i'ere just the setting of a pointer to
the old file. This, admittedly is an extreme and contrived
example, but it illustrates quite well the type of problem that
can arise.
Hence, in general, pointers are dangerous. We certainly
demonstrated sufficiently well in Chapter 3 that K-trees can be
constructed and used without explicit pointers. The only
exception came with the. best cost backtracking algorithm of
Section 3.3, in which pointers were used for indexing from the
priority queue to the K-tree. This is one use of pointers that
seems difficult to avoid. However, one can build in sufficient
protection to prevent abuses. ThUS, one might permit only the
currently active element to be assigned to a pointer variable,
and let this assignment, a deal location operation, and one
or two predicates be the only means of making reference to a
pointer. Whenever an element that has a pointer associated with
it becomes active, a move operation makes active the element
that is being pointed to. To prevent dangling pointers one
might require that all pointers that point to an element be
deallocated before the element can be erased. Alternatively,
erasure of the element might be made to trigger deal location of
all pointers that reference it. Both of these approaches could
become very costly if the node being erased were the root of a
large subtree. Strong typing as in Pascal would have to be
required.

4.2 Levels of abstraction

These days it is difficult to find an article on data

structures which does not have on its first or second page some
 72

part or variant of the following:

queue
new: ~ queue,
push: queue x item ~ queue,
pop : queue - - ? queue,
peek: queue - - ? item,
null: queue~Boolean;

-
forall q E queue,
null (new)
i E item let
~,

peek (new) error,

pop (new) error,
null (push(q,i» false,
peek (push(q,i» if null(q) then i
~ peek(q),
pop (push(q,i» if null(q) ~ new
~ ~,: t~ push (pop (q) ,i)
endtype;

This is an example of the axiomatic approach t~ the definition

of data structures. The properties of the operations are
expressed by axioms, i.e., expressions that relate the operations
to each other. Standish finds ten potential advantages in the
axiomatic approach. He states that it might eventually be
expected

1. To permit clear, rigorous definition of the concepts

of data representations and data types.
2. To specify precisely the requirements on data
representations.
3. To specify precisely the requirements on programs that
manipulate data representations.
4. To permit the widest possible selection of implement-
ation detail.
~. To simplify program maintenance by allowing changes in
superstructure or underpinnings to be made independently.
 IJ

7. To permit concise definition of the semantics of data

definition facilities.
8. To establish a framework for tackling the problem of
automatic synthesis or selection of data
representations.
9. To capture the behavior of composite information of
structures that are pervasive in programming.
10. To offer a better basis for machine independence.

A second approach to abstract data structures is to provide

an operational specific~tion. Instead of defining the operations
in terms of each other, they are described by procedures
expressed in some programming language. The two disadvantages
of this approach ~a that the operational specifications may
eventually become very long, and that it is difficult to keep out
extraneous detail from them, which may limit the independence
of data structures and storage structures somewhat.
On the other hadd, sooner or later one does have to
execute computer instructions, and there has not as yet been
found an algorithm to take one from abstract specification (59)
to computer instructions, Moreover, a new constraint has been
introduced. The selection of operations that are to be provided
cannot be but influenced by the ease with which the corresponding a
axiomatic specification can be set up. So, in (59) the sequence
of operations peek and pop has replace~ what we have traditionally
understood by the pop operation.
The last observation suggests that a system should be made
to provide an operation that does combine the two, and, in general.
that a superstructure can be created on top of the axiomatic
definition, where, because we are composing operations whose
properties are preciesly known, a lot of dependability is built in.
Otherwise we could not cope with anything as complicated as our
12 or 18 binary tree traversals.
A program is now expressed in terms of abstract data structures,
and mappings have to be provided for going from this level to that
of the storage structures. The mappings must certainly be
correctness preserving, and one would hope that they would be
complexity preserving as well. Moreover, the operations cannot
 74

now be regarded in isolation. For example, if the program based

on a tree traversal requires examination of the path from root to
active node, then threads would not provide an efficient means for
driving the traversal. Suppose the parent of a node is to be
found. In our algori~hms, n order that O(m) complexity be
maintained, this has to be done in constant time. Again, if
threads were used, this determination could cost o(n), where n
is the number of D-nodes.
FURTHER READING

Texts on recurrence relations:

S. Goldberg, Introduction to Difference Equations, Wiley,

.
New York,
. 1958.
H. Levy and F. Lessman, Finite Difference Equations,
Macmillan, New York, 1961.

Good introduction to generating functions and recurrences:

C. L. Liu, Introduction to Combinatorial Mathematics,
McGraw-Hill, New York, 1968.

Advanced text on recurrences:

J. Aczel, Lectures on Functional Equations and Their
Applications, Academic Press, New York, 1966.

Balancing of AVL trees after a deletion is treated in:

E. M. Reingold, J. Nievergelt, and N.Deo, combinatorial
Algorithms: Theory and Practice, Prentice-Hall,
Englewood Cliffs, N.J., 1977.

A proof of the cycles algorithm can be found in:

A. T. Berztiss, Data Structures: Theory and Practice,
2nd Ed., Academic Press, New York, 1975.

An excellent example of how one programs in a definitional and

a operational environment is provided by Codd's relational
algebra and relational calculus in:
C. J •. Date, An Introduction to Database systems, Addison-
Wesley, Reading, Mass., 1975.