Recursive Data Structures
Read this page. In the previous unit of our course we studied recursive algorithms. Recursion is a concept that also applies to data. Here we look at recursive data structures - lists, trees, and sets. A list is a structure that consists of elements linked together. If an element is linked to more than one element, the structure is a tree. If each element is linked to two (sub) elements, it is called a binary tree. Trees can be implemented using lists, as shown in the resource for this unit. Several examples of the wide applicability of lists are presented. A link points to all the remaining links, i.e. the rest of the list or the rest of the tree; thus, a link points to a list or to a tree - this is data recursion.
The efficiency of the programming process includes both running time and size of data. This page discusses the latter for recursive lists and trees.
Lastly, why read the last section on sets? Sets are another recursive data structure and the last section 2.7.6, indicates their connection with trees, namely, a set data type can be implemented in several different ways using a list or a tree data type. Thus, the programming process includes implementation decisions, in addition, to design or algorithm decisions. Each of these types of decisions is constrained by the features of the programming language used. The decision choices, such as which data structure to use, will impact efficiency and effectiveness of the program's satisfaction of the program's requirements.
Note: You will notice an unusual use of C++ here. What the author is doing is showing how to pass a fixed-value data-structure as a calling argument.
2. An exercise: rotating a square
Here is a square composed of elements, perhaps pixels or cells that are on or off. We could write them out like this:
⚪️⚪️⚪️⚪️⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚫️⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️⚫️⚪️⚪️⚪️ ⚪️⚪️⚫️⚫️⚫️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️⚪️⚪️⚪️⚪️
Consider the problem of rotating our square. There is an uncommon, but particularly delightful way to do this. First, we cut the square into four smaller squares:
⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚫️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚫️⚪️⚪️⚪️ ⚪️⚪️⚫️⚫️ ⚫️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️
Now, we rotate each of the four smaller squares 90 degrees clockwise:
⚪️⚪️⚪️⚪️ ⚫️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚫️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚫️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚫️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚫️ ⚪️⚪️⚪️⚪️
Finally, we move the squares as a whole, 90 degrees clockwise:
⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚫️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚫️ ⚪️⚫️⚪️⚪️ ⚪️⚪️⚪️⚫️ ⚫️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️
⚪️⚪️⚪️⚪️⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚫️⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚫️⚪️⚫️⚪️⚪️ ⚪️⚪️⚪️⚫️⚫️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️⚪️⚪️⚪️⚪️
How do we rotate each of the four smaller squares? Exactly the same way. For example,
⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚫️ ⚪️⚪️⚪️⚫️
⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚪️⚫️ ⚪️⚪️ ⚪️⚫️
By rotating each smaller square, it becomes:
⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚫️⚫️
And we rotate all for squares to finish with:
⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚪️⚪️ ⚫️⚫️ ⚪️⚪️
Reassembled, it becomes this:
⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚪️⚪️⚪️⚪️ ⚫️⚫️⚪️⚪️
How would we rotate the next size down?
⚪️ ⚪️ ⚫️ ⚫️
Rotating an individual dot is a NOOP, so all we have to do is rotate the four dots around, just like we do above:
⚫️ ⚪️ ⚫️ ⚪️
Reassembled, it becomes this:
Voila! Rotating a square consists of dividing it into four "region" squares, rotating each one clockwise, then moving the regions one position clockwise. It brings whirling dervishes to mind.
Here's the algorithm in action: