Algorithms and Data Structures

N.Wirth. Algorithms and Data Structures. Oberon version 101
Programs in which the use of algorithmic recursion is to be avoided can be characterized by a schema
which exhibits the pattern of their composition. The equivalent schemata are shown below. Their
characteristic is that there is only a single call of P either at the end (or the beginning) of the composition.
P ≡ IF B THEN S; P END
P ≡ S; IF B THEN P END
These schemata are natural in those cases in which values are to be computed that are defined in terms of
simple recurrence relations. Let us look at the well-known example of the factorial numbers f i = i!:
i = 0, 1, 2, 3, 4, 5, ...
f i = 1, 1, 2, 6, 24, 120, ...
The first number is explicitly defined as f 0 = 1, whereas the subsequent numbers are defined recursively in
terms of their predecessor:
f i+1 = (i+1) * f i
This recurrence relation suggests a recursive algorithm to compute the n-th factorial number. If we
introduce the two variables I and F to denote the values i and f i at the i-th level of recursion, we find the
computation necessary to proceed to the next numbers in the sequences to be
I := I + 1; F := I * F
and, substituting these two statements for S, we obtain the recursive program
P
≡ IF I < n THEN I := I + 1; F := I * F; P END
I := 0; F := 1; P
The first line is expressed in terms of our conventional programming notation as
PROCEDURE P;
BEGIN
IF I < n THEN I := I + 1; F := I*F; P END
END P
A more frequently used, but essentially equivalent, form is the one given below. P is replaced by a function
procedure F, i.e., a procedure with which a resulting value is explicitly associated, and which therefore may
be used directly as a constituent of expressions. The variable F therefore becomes superfluous; and the role
of I is taken over by the explicit procedure parameter.
PROCEDURE F(I: INTEGER): INTEGER;
BEGIN
IF I > 0 THEN RETURN I * F(I - 1) ELSE RETURN 1 END
END F
It now is plain that in this example recursion can be replaced quite simply by iteration. This is expressed
by the program
I := 0; F := 1;
WHILE I < n DO I := I + 1; F := I*F END
In general, programs corresponding to the original schemata should be transcribed into one according to
the following schema:
P
≡ [x := x0; WHILE B DO S END]
There also exist more complicated recursive composition schemes that can and should be translated into
an iterative form. An example is the computation of the Fibonacci numbers which are defined by the
recurrence relation