Nodes: Swift

Now that we can create sequences of nodes, let’s see them in action!

Imagine we are working at an ice cream shop that sells three flavors: strawberry, banana, and coconut. The signature fruity sundae is made of these three flavors, but our new hires have a hard time remembering the order.

To help them remember, our Swift nodes may do just the trick. 

Let’s get started…

Printing Nodes Iteratively

Nodes are the building blocks for many of the data structures to follow in this path. Recall that we defined nodes earlier as data structures that contain links, or references, to other nodes. In this lesson, we will get to work closely with nodes in the context of Swift.

We’ll use a class, Node, to model our nodes, and since Swift doesn’t allow value types like structs to hold references but only copied values, we'll be using a reference type, classes, instead. 

With this Swift implementation of a node, we will create a chain of nodes with properties that store data and provide ways to programmatically visit each node in the chain using iteration and recursion.

Let's get started!



Frame 1: Three nodes represented by ellipses labeled node_a, node_b, and node_c. node_a links to node_b, which is represented by an arrow pointing from node_a to node_b. node_b links to node_c, which is represented in the same way.
Frame 2: node_a is updated to link to node_c. The arrow pointing from node_a to node_b has been removed, and a new arrow pointing from node_a to node_c has been added, bypassing node_b.
Frame 3: node_b has been orphaned, which is indicated by a large red X over the ellipse representing node_b.
Frame 4: node_b has been removed, leaving only two nodes, node_a and node_c. node_a still links to node_c.


Introduction: Nodes in Swift

Currently, when a `Node` is created, it does not refer to its next `Node`. Recall that nodes contain links to other nodes​​, and when the following node is `nil` we’ve likely reached the end of the path. To portray this concept, we’ll need a separate property where the reference to the next node will be stored. 

With the `next` property, we can traverse a sequence of `Node`s by visiting a `Node` and checking what the next `Node` in the sequence is.



Defining the Next Node

In the previous exercise, the function `printAllNodes()` visited each of the `Node`s in the ice cream sequence in an iterative manner, repeatedly setting and then re-setting the value assigned to `unwrappedNode`. In this exercise, we'll create a function that also visits each of the `Node`s in the ice cream sequence but does so in a different way: *recursively*.



Printing Nodes Recursively

Now that you have an understanding of what nodes are, let's see a Swift implementation!

We will create a basic `Node` class that contains data and a link to the next `Node`. Our `Node`'s data will be specified as a `String` but the same class could easily be changed to hold any other data type. Remember that a `Node`'s link to the next `Node` is `nil` when there are no more nodes to traverse.

Take a look at the starter code in the editor. You will find the `Node` class defined for you.

