Learn to implement the queue data structure in Swift.

Queues: Swift

Great work!  Now that we have a basic structure of our Queue, let's test its abilities! To be able to retrieve the head, or tail, or see the output from any of the functions we've built, we've added conformance to `CustomStringConvertible` so that you can `print` queue directly.

Printing the Queue

Since our queue is currently empty, let’s add to it! To enqueue literally means "add to the queue". In creating the `enqueue()` method, that’s exactly what we’ll do.

When adding a new node to the queue, the new node is always added to the end of the queue.

* If the queue is empty, the new node becomes the head and tail of the queue. (Imagine only one person is in line).
* If the queue has at least one other node, the new node becomes the new tail. (Someone joins a line of people).

We can put this into action by creating the `enqueue()` method of the Queue struct. 

Defining the Enqueue() Method 

Recall from the conceptual lesson that the `peek()` method will allow us to view the head of the queue without returning it. Let's implement this functionality in our  `Queue` struct.




Defining the Peek Method

We can add items to the tail of our queue, but when we remove them, we remove them from the head. Remember that this protocol is described as first in, first out (FIFO). The method that performs this is called `dequeue()`, or "remove from the queue".

This method removes the head node and replaces it with the following node. It also returns the head node.

- If the queue has one node, when we remove it, the queue will be empty. (Imagine only one person was in line).
- If the queue has more than one node, we remove the head node and reset the head to the following node. (Once the first person places their order, the next person in line moves up).

Let's add this functionality to our Queue structure next. 

Defining the Dequeue Method

In its entirety, a queue is a data structure that contains an ordered set of data that follows a FIFO (first in, first out) protocol. You can visualize it as a line at a deli:

- The customer at the front of the line (equivalent to the _head_ in a queue) is the first customer to get served.
- Any new customer must go to the back of the line (the _tail_ of the queue) and wait until everyone in front of them has been served (no line cutters allowed in this deli!)
- The deli server only needs to know about the current order.

Now, we can use Swift to build out a `Queue` struct with those three essential queue methods:

- `enqueue()` which will allow us to add a new node to the tail of the queue.
- `dequeue()` which will allow us to remove a node from the head of the queue and return its value.
- `peek()` which will allow us to view the value of the head of the queue without returning it.

Ready, set, queue up!