Learn how to implement the stack data structure using Swift.


Stacks: Swift

Stacks operate by making modifications just to the top, or _head_, of the stack. If we want to add a plate to our dish stack, we add it to the top of the pile. To add an item to the stack, we will use the `.push()` method. Our `.push()` method will: 

- Add an item to the stack. 
- Print a statement that notifies the user of the changes to the stack.

Keep in mind that our stack is an instance of a `LinkedList` which is built using the `Node` class, thus we can rely on their properties and methods to help us in our implementation.


Adding the Push Method

Now that we have items on our stack, and we know how to `peek` at the one on the top, we need to implement the removal of the topmost item off the stack. We'll call this method, `pop()`. 

As shown in the previous exercises, we need to operate on the `LinkedList` to return the `head` of the stack. We'll leverage a `removeHead()` method in our code from the `LinkedList` class to achieve this.

Let's get started!

Adding the Pop Method

Once we’ve added nodes to a stack, we have the option to inspect the one on the top of the stack! As with the dishes example, you can only see the one at the top. We will be implementing this same functionality by creating a `peek()` method. The method will return the top of the stack if it exists. Some things to keep in mind as we build out this method: 

- To implement `peek`, we will want to use our `LinkedList` class to look at the `head` value of the linked list. This has to be done with a little care because if the `Stack` is empty, this value will be `nil`, and we do not want to attempt to return `nil`. This will cause a crash!
- Unlike the `push()` method, the `peek()` method does **not** alter the Stack.


Adding the Peek Method

As you may recall, a _stack_ is a linear data structure that contains an ordered set of data that follows a _LIFO_ (last in, first out) protocol for accessing its data. A stack can be imagined as a literal stack of dishes to wash. As people finish eating they put their plate on top of the stack. The dishwasher will then take the plate off starting at the top of the stack. Since you have an understanding of how stacks work in theory, now let’s see how they can be useful in the wild -- with Swift! 
 
Remember that there are three main methods we want our stacks to have:
 
* `.push()`: adds data to the top of the stack
* `.pop()`: removes data from the top of the stack
* `.peek()`: views the data at the top of the stack **without** removing it
 
We will also need to consider the stack’s size and tweak our methods a bit so that our stack does not “overflow” or “underflow”.
 
If you've taken our course where we created a linked list, you'll see that many of the methods we created there will work perfectly for our stack implementation. To create a stack, we will use both our well-established `LinkedList` and `Node` data structures. 
 
Let’s get started building our `Stack` struct!

Introduction to Stacks in Swift

Our `Stack` implementation is now complete. We can `push`, `pop`, and `peek` values on the `Stack`. As we know if we attempt too many `pop`s eventually `nil` is returned as there are no `Node`s on the stack.

However, what happens if we keep adding nodes onto the `Stack`? There is nothing limiting the size of the stack! As we know with dishes, if the pile of dishes gets too high we may have a crash! This is the same for us, `Stack`s take up memory and in many cases, we will want a limit on the size.

In this exercise, we will extend our `Stack` class to have the concept of maximum size.