Implement the graph data structure in Swift.

Graphs: Swift

The `Graph`, `GraphNode`, and `GraphEdge` structures are almost complete! The last piece to the current Graph implementation is the ability to remove nodes. 

Removing a node in a graph is a bit more complex as compared to removing one from a tree. We'll need to:

- Remove it from the `nodes` array
- Remove any edges that contain the node from the `edges` array
- Remove the node from any *other* nodes's `neighboringNodes` array.


Removing Nodes

With `GraphNode` complete, let's implement the the `GraphEdge` structure.

The `GraphEdge` structure represents the connection between graph nodes. It will hold each conjoined node as a property. 

Let's create the `GraphEdge` structure and define `Graph` functions to add edges in the graph.


Implementing Graph Edges

Directed graphs, as the name denotes, are graphs where the edges are directed to another node. Just because `A` points to `B` doesn't mean that `B` points to `A`. 

To implement directed graphs, we'll need to add a parameter for bidirectional support instead of all edges being bidirectional by default.

Undirected graphs are a bit easier! They are graphs where the edges are not directed to one another. That is, `A` points to `B` and `B` points to `A` with the same edge.

To implement undirected graphs, we'll use the parameterized bidirectional support used for directed graphs.

Let's add bidirectional support to our graph.


Directed and Undirected Graphs

A weighted graph is a graph where the edges are associated with a numeric value.

Weighted graphs are usually directed graphs but it a graph can be both weighted and undirected. If a graph is undirected, the edge is weighted the same for both directions. 

One example of a directed graph is a commercial flight map. The nodes are the airports, the edges are the flights from airport to airport, and the weights are the prices of the flights.

Let's update our `GraphEdge` and `Graph` to allow for weights.


Weighted Graphs

Great work! Your `Graph` class can be used to build graphs of all shapes and sizes. Let's recap the types of graphs we've built and how they modified our implementation.

- **Acyclic graphs**: A graph is acyclic if there are no graph cycles. Acyclic graphs had no change to the base implementation. 
- **Cyclic graphs**: A graph is cyclic if there is at least one graph cycle. Cyclic graphs also did not change the base implementation. This graph, however, greatly changes how to search graphs (you'll see this in future lessons!)
- **Undirected graphs**: Since undirected graphs can travel in both directions from node to node, bidirectional edge support was implemented. 
- **Directed graphs**: Directed graphs are graphs that dictate the direction in which edges can be traversed. This changed bidirectional support to be an optional request instead of a requirement.
- **Weighted graphs**: Weighted graphs provide a numeric value to edges. Since weights are not a requirement when building graphs, our implementation included overloading functions to ensure multiple uses of adding an edge to a graph existed. 

Now that our `Graph` class supports the use of a variety of graphs, let's create a graph to visualize commercial airliners to put each of the pieces to use!


Review

Cyclic graphs are graphs that contain at least one cycle. This means that as you traverse the graph, somewhere in the graph, it is possible to leave a node and return to that same node through the cycle. 

Consider the following sequence of events for learning how to ride a bike:
- You get on the bike
- You begin pedaling the bike
- You fall down
- You get back on the bike

The cycle of getting on the bike, pedaling, and falling off will happen until you have successfully mastered riding a bicycle. There is no restraint on how many times this could take, and happens a lot when you're learning!

Let's create the cyclic graph above using Swift.

Cyclic Graphs

Acyclic graphs are graphs that do not contain a graph cycle. This means that as you traverse the graph, once you leave a node, there is no path back to that node. Let's take a closer look at acyclic graphs using an example.

Consider the following sequence of events:
You are presented with the options for getting to work:

1. Driving
1. Taking the bus

Either way, you'll end up at the office.  Once at work, you can't undo the schedule of events and decide to take the car.  In an acyclic graph, once a decision to traverse down a path is made, the decision cannot be undone since there is no path back to the previous node. 

Let's take this knowledge and build an acyclic graph!

Acyclic Graphs

In this lesson, we'll define the necessary structures to implement the Graph data structure in Swift. Similar to the Trees lesson, we'll define the base class `Graph` and a `GraphNode` structure to contain the data for each node in the graph. Additionally, we'll need to define a structure to connect the nodes within the graph. This is important because graphs are not bounded by the parent-children relationship. 

As we build out these structures and classes, we'll need to ensure that our `Graph` implementation is flexible enough to support a variety of graphs. Our implementation will focus on supporting acyclic, cyclic, undirected, and weighted graphs. 

With this in mind, let's change the `GraphNode` structure to account for the `Graph` data structure.  The initial code provided is a starting point with the `Tree` implementation from an earlier lesson.