It is the end of the Base.cs series, so we answer some of your questions and take a look back at some of our favorite moments!

This episode is going to make you want to dance the JIT-ter Bug.

What are you going to choose, compilation or interpretation?

We get into abstract syntax trees, (usually just referred to as an AST), which is really nothing more than a simplified, condensed version of a parse tree.

We phase into understanding compilers by getting into phase one of how compilers work: lexical analysis.

What exactly is a the computer version of a “sentence”? And how do we go about diagramming it, exactly?

In our last episode we were a little disappointed that our salesperson was traveling in factorial time, so now we are speeding them up!

Make your salesperson the most efficient around by using the Hamiltonian path.

Get the memo and memoize!

"I will not repeat myself again." - Dynamic Programming

We use Dijkstra's algorithm to find the shortest path from one node to another in a complicated house-shaped graph. Also, Viadahi sings us a song.

To get from one point to any other point in a graph, make Dijkstra your weapon of choice.

DAG-nabbit! Don't forget to check whether or not a graph is a directed acyclic graph.

Traversing through a graph is pretty edgy.

To go about coding the depth-first search algorithm (DFS), we revisit an old friend: adjacency lists.

When going through a maze, hitting a dead end isn't always a bad thing, especially in depth-first search (DFS).

Take a deep breath as we dive into breadth-first search, a super nifty graph traversing algorithm, which gives the shortest way to get from one node to another.

Adjacency lists are the new type of hybrid you're going to want to be driving around your code.

We tackle representing graphs and the parts that make it up.

You won't want to miss the buzz about b-trees, the general version of a 2-3 tree, and a super efficient data storing tree structure.

We dive into a tree data structure that can contain more than one key, which is unlike any tree structure we've covered so far. It is also the reason for their name: 2-3 tree.

If you thought self-balancing AVL trees were cool, just wait till you learn about red-black trees, which also run in logarithmic time!

Listen and learn about a pattern that you can use to figure out the minimum number of nodes we’ll need to create any height-balanced AVL tree, how it leads us to the Fibonacci sequence, and the golden ratio.

We look at the earliest version of the height-balanced tree concept: the AVL tree.