Algorithms and Data Structures

N.Wirth. Algorithms and Data Structures. Oberon version 129
4 Dynamic Information Structures
4.1 Recursive Data Types
In Chap. 1 the array, record, and set structures were introduced as fundamental data structures. They
are called fundamental because they constitute the building blocks out of which more complex structures
are formed, and because in practice they do occur most frequently. The purpose of defining a data type,
and of thereafter specifying that certain variables be of that type, is that the range of values assumed by
these variables, and therefore their storage pattern, is fixed once and for all. Hence, variables declared in
this way are said to be static. However, there are many problems which involve far more complicated
information structures. The characteristic of these problems is that not only the values but also the
structures of variables change during the computation. They are therefore called dynamic structures.
Naturally, the components of such structures are — at some level of resolution — static, i.e., of one of the
fundamental data types. This chapter is devoted to the construction, analysis, and management of dynamic
information structures.
It is noteworthy that there exist some close analogies between the methods used for structuring
algorithms and those for structuring data. As with all analogies, there remain some differences, but a
comparison of structuring methods for programs and data is nevertheless illuminating.
The elementary, unstructured statement is the assignment of an expression's value to a variable. Its
corresponding member in the family of data structures is the scalar, unstructured type. These two are the
atomic building blocks for composite statements and data types. The simplest structures, obtained through
enumeration or sequencing, are the compound statement and the record structure. They both consist of a
finite (usually small) number of explicitly enumerated components, which may themselves all be different
from each other. If all components are identical, they need not be written out individually: we use the for
statement and the array structure to indicate replication by a known, finite factor. A choice among two or
more elements is expressed by the conditional or the case statement and by extensions of record types,
respectively. And finally, a repetiton by an initially unknown (and potentially infinite) factor is expressed by
the while and repeat statements. The corresponding data structure is the sequence (file), the simplest kind
which allows the construction of types of infinite cardinality.
The question arises whether or not there exists a data structure that corresponds in a similar way to the
procedure statement. Naturally, the most interesting and novel property of procedures in this respect is
recursion. Values of such a recursive data type would contain one or more components belonging to the
same type as itself, in analogy to a procedure containing one or more calls to itself. Like procedures, data
type definitions might be directly or indirectly recursive.
A simple example of an object that would most appropriately be represented as a recursively defined
type is the arithmetic expression found in programming languages. Recursion is used to reflect the
possibility of nesting, i.e., of using parenthesized subexpressions as operands in expressions. Hence, let an
expression here be defined informally as follows:
An expression consists of a term, followed by an operator, followed by a term. (The two terms
constitute the operands of the operator.) A term is either a variable — represented by an identifier — or
an expression enclosed in parentheses.
A data type whose values represent such expressions can easily be described by using the tools already
available with the addition of recursion:
TYPE expression = RECORD op: INTEGER;
opd1, opd2: term
END