Comparing changes

@@ -0,0 +1,9 @@
+# Scheduling & Binary Search Trees
+
+* Airport with a single runway.
+* Reservations for future landings.
+* Reserve request specifies landing time t
+* Add `t` to the set `R` of landing times if no other landings are scheduled within `k` minutes.
+* Remove from set `R` after plane lands.
+* `|R| = n`
+* `O(lg n)` time where `n` is the size of the set.

@@ -0,0 +1,226 @@
+# Hashing
+
+[video][mit-ocw]
+
+## Motivation
+
+* database
+* compilers and interpreters
+* network router
+* substring search
+* string commonalities
+* file/dir synchronization
+
+Direct Access table:
+
+  ----------
+0 |        |
+  ----------
+1 |        |
+  ----------
+2 |        |
+  ----------
+3 |        |
+  ----------
+4 |        |
+  ----------
+  | ...    |
+  ----------
+  | ...    |
+  ----------
+  | ...    |
+  ----------
+
+> Hash requires mapping to an integer.
+
+ideally:
+
+* prehash hash(x) == hash(y) only when x == y
+
+badness:
+
+1. keys may not be non negative integers
+1. gigantic memory hog
+
+hashing -> hatchet
+
+- reduce universe of all possible keys and reduce them down to some reasonable set of integers.
+- idea: m = theta(n)
+  - size of table proportial to size of # of things.
+
+    -----------
+0   | | | | | |
+    ----------
+1   |         |
+    ----------
+2   |         |
+    ----------
+3   |         |
+    ----------
+4   |         |
+    ----------
+    | ...     |
+    ----------
+    | ...     |
+    ----------
+m-1 | ...     |
+    ----------
+
+Collision: Multiple keys map to same slot in hash table.
+* h(ki) == h(kj) but ki <> kj
+* we can use chaining
+
+How to define?
+
+* function (h)
+* all keys map to `h = { 0, ..., m-1 }`
+
+Two ways to deal with collisions:
+
+* Chaining: store collisions as a list. (i.e. linked list)
+* Open addressing
+
+## Chaining
+
+    ----------
+0   |         | --> (item1) --> (item2) --> (nil)
+    ----------
+1   |         |
+    ----------
+2   |         |
+    ----------
+3   |         |
+    ----------
+4   |         |
+    ----------
+    | ...     |
+    ----------
+    | ...     |
+    ----------
+m-1 | ...     |
+    ----------
+
+Worst case:
+
+* theta(n) (i.e. all items have a collision)
+
+Simple uniform hashing:
+
+* Convenient for analysis.
+* each key is equally likely to be hashed to any slot of the table, independent of where other keys hashing.
+
+Analysis:
+
+* expected length of a chain for n keys, m slots.
+  * n/m == alpha == load factor
+  * O(1 + alpha)
+
+## Hash functions:
+
+1. division method:
+  * `h(k) == k mod m`
+  * works okay if `m` is prime and not close to power of 2 or power of 10.
+2. multiplication method:
+  * `h(k) = [(a*k) mod 2^w] >> (w - r)`
+3. Universal hasing:
+  * `h(k) = [(ak+b) mod p] mod m`
+    * `a`, `b` are random between 0 and `p-1`. p is a big prime number larger than the universe.
+    * `{0, ..,p-1}`
+  * worst case keys: k1 != k2
+    * `1/m`
+
+## How to choose m?
+
+* Want `m = theta(n)`
+  * `0(1)`
+
+Idea:
+
+> Start small; grow/shrink as necessary
+
+E.g.
+
+* If n > m: grow table
+
+* grow table:
+  * m -> m'
+    * make table of size `m'`
+    * build new hash function `h'`
+    * rehash
+      * for item in T:
+        * t:insert(item)
+    * `m' = 2m` table doubling
+
+Amortization:
+* operation takes `T(n) amortized`
+  * if `k` operations take <= `k*T(n)` time
+* spread out the high cost so you pay a little bit, but more often.
+* ~ Think of meaning `T(n)` on average, where average is taken over all the oeprations.
+
+> spread out the high cost so that it's cheap on average all the time.
+
+## Open Adressing
+
+* no chaining
+* use arrays
+* m: # of slots in the table
+* m >= # of elements
+
+```plaintext
+----------
+| item 1 |
+----------
+| item 2 |
+----------
+|        |
+----------
+|        |
+----------
+```
+
+probing: try to see if we can insert something into the hashtable.
+if we fail, we will compute a slightly different hash until we
+find an empty slot that we can insert into this table.
+
+Hash function specifies the order of slots to probe
+for a key. (for insert/search/delete)
+
+hash function `h(U, trial_count)`
+
+* U: universe of keys
+* trial_count: integer between 0 -> m-1
+
+`h(k,1)`
+arbitrary key k
+
+h(k,1), h(k,2), ... h(k, m-1)
+
+to be a permutation of 0,1 ... m-1
+
+```plaintext
+  ----------
+0 |        |
+  ----------
+1 |        |
+  ----------
+2 |        |
+  ----------
+3 |        |
+  ----------
+4 |        |
+  ----------
+5 |        |
+  ----------
+6 |        |
+  ----------
+7 |        |
+  ----------
+```
+
+* `insert(k,v)`: keep probing until an empty slot is found. insert item when found.
+* `search(k)`: As long as the slots encountered are occupied by keys != k. keep probing until you either encounter k or find an empty slot.
+
+## Cryptographic Hash
+
+
+[mit-ocw]: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/lecture-videos/lecture-8-hashing-with-chaining/

@@ -0,0 +1,74 @@
+# Karp-Rabin string matching algorithm
+* https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/lecture-videos/lecture-9-table-doubling-karp-rabin/
+
+* given two string `s` & `t`: does `s` occur as a substring of `t`?
+
+```plaintext
+t: [ | | | | | | | | | | | | | | | | ]
+s: [ | | | ]
+  s: [ | | | ]
+    s: [ | | | ]
+      s: [ | | | ]
+        s: [ | | | ]
+          s: [ | | | ]
+            s: [ | | | ]
+              s: [ | | | ]
+                s: [ | | | ]
+                  s: [ | | | ]
+                    s: [ | | | ]
+                      s: [ | | | ]
+                        s: [ | | | ]
+                          s: [ | | | ]
+```
+
+Time:
+  * `theta(|s| * |t| - |s|)
+  * `theta(|s| * |t|) # length of s * length of t
+
+Can we use hashing to get this down to linear time?
+
+* We are looking for `O(|s|+|t|)` length of `s` + `t` is better than `s` times `t`.
+
+Rolling hash ADT:
+
+* `r.append(c)`:
+  * add char.c to end of x
+* `r.skip(c)`:
+  * delete fist character of x (assuming it is c)
+
+
+* `r` maintains a string `x`
+  * `r()` hash value of x = `h(x)`
+
+```python
+for c in s: rs.append(c)
+for c in t[:len(s)]:
+  rt.append(c)
+if rs() == rt(): ...
+for i in range(len(s), len(t)):
+  rt.skip(t[i - len(s)]
+  rt.append(t[i])
+  if rs() == rt:
+    s == t[i-len(s) + 1: i + i]
+    if equal:
+      found match
+    else:
+      happens with probability <= 1/|s|
+```
+
+division method:
+* `h(k) = k mod m` where `m` is a random prime >= |s| (prime is greater than length of s)
+* treat string x as a multi digit number base is size of alphabet.
+  * ascii -> 256
+  * unicode -> x
+
+```python
+r.append(c):
+  u -> u * a + ord(c)
+  r -> r * a + ord(c) mod m
+
+r.skip():
+  u -> u - c * a^|u|-1
+```
+
+* https://www.youtube.com/watch?v=qQ8vS2btsxI

@@ -0,0 +1,27 @@
+# Chapter 8: Scapegoat Trees
+
+> when something goes wrong, the first thing people tend to do is find someone to blame (the scapegoat).
+
+A Scapegoat tree implements the Sorted Set, `SSet`, interface.
+The tree supports the operations:
+
+| operation | time complexity |
+| ------------- | ------------- |
+| `add()` | O(log n) |
+| `remove()` | O(log n) |
+| `find()` | O(log n) |
+
+Balanced by partial rebuilding operations.
+
+* keeps track of the number of nodes `n`.
+* keeps a counter, `q`, that maintains an upper-bound on the number of nodes.
+
+At all times, `n` and `q` obey the following inequalities:
+
+> q/2 <= n <= q
+
+credit schema: Each node stores a number of credits.
+
+## Resources
+
+* http://people.csail.mit.edu/rivest/pubs/GR93.pdf

@@ -0,0 +1,84 @@
+#include "binary_tree.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+/**
+ * Initialize a new node for a Binary Tree.
+ *
+ * @param data the data to assign to the root of the tree.
+ * @return The root of the binary tree.
+ */
+Node *initialize(int data) {
+  Node *item = malloc(sizeof(Node));
+  item->data = data;
+  item->left = NULL;
+  item->right = NULL;
+  return item;
+}
+
+/*
+ * Traverses a binary tree using the traversal algorithm specified.
+ * Time: O(n)
+ * Space: O(n) for each recursive stack frame
+ *
+ * @param node The root of the binary tree
+ * @param vistior A callback function to invoke on each node during the tree
+ * traversal
+ * @param traversal Specifies what type of traversal to perform
+ */
+void traverse(Node *node, Visitor visitor, enum Traversal traversal) {
+  if (!node)
+    return;
+
+  switch (traversal) {
+  case PREORDER:
+    visitor(node);
+    traverse(node->left, visitor, traversal);
+    traverse(node->right, visitor, traversal);
+    break;
+  case INORDER:
+    traverse(node->left, visitor, traversal);
+    visitor(node);
+    traverse(node->right, visitor, traversal);
+    break;
+  case POSTORDER:
+    traverse(node->left, visitor, traversal);
+    traverse(node->right, visitor, traversal);
+    visitor(node);
+    break;
+  default:
+    visitor(node);
+    break;
+  }
+}
+
+/**
+ * Frees the memory allocated for a node in a tree
+ *
+ * @param node The node in the binary tree to free
+ */
+static void destructor(Node *node) { free(node); }
+
+/**
+ * Frees the memory associated with each node in a binary tree.
+ *
+ * @param root The root of the tree
+ */
+void destroy(Node *root) { traverse(root, destructor, POSTORDER); }
+
+/**
+ * A helper method to print out a visual representation of the tree
+ *
+ * @param node A node in a binary tree.
+ * @param level The level in the tree that the node is at
+ */
+void inspect(Node *node, int level) {
+  if (!node)
+    return;
+
+  for (int i = 0; i < level; i++)
+    printf("  ");
+  printf("(%d)\n", node->data);
+  inspect(node->left, level + 1);
+  inspect(node->right, level + 1);
+}

@@ -0,0 +1,30 @@
+/**
+ * A struct to represent a node in a Binary Tree
+ */
+struct node {
+  int data;
+  struct node *left;
+  struct node *right;
+};
+
+typedef struct node Node;
+
+/**
+ * A signature of a function pointer
+ * that can be used to traverse a binary tree.
+ */
+typedef void(Visitor)(Node* node);
+
+/**
+ * The different types of traversals that the binary tree can perform
+ */
+enum Traversal {
+  INORDER = 1,   // In order traversal
+  PREORDER = 2,  // Pre order traversal
+  POSTORDER = 4  // Post order traversal
+};
+
+Node *initialize(int data);
+void traverse(Node *node, Visitor visitor, enum Traversal traversal);
+void destroy(Node *head);
+void inspect(Node *head, int level);

@@ -0,0 +1,397 @@
+#include "binary_tree.h"
+#include <cgreen/cgreen.h>
+#include <string.h>
+
+int visited[32];
+Node *nodes[32];
+int visited_count;
+
+Describe(BinaryTree);
+BeforeEach(BinaryTree) {
+  memset(visited, 0, sizeof(visited));
+  memset(nodes, 0, sizeof(nodes));
+  visited_count = 0;
+}
+AfterEach(BinaryTree) {}
+
+void visitor(Node *node) {
+  visited[visited_count] = node->data;
+  nodes[visited_count] = node;
+  visited_count++;
+}
+
+Node *next(Node *self, Node *x, enum Traversal traversal) {
+  traverse(self, visitor, traversal);
+
+  for (int i = 0; i < visited_count; i++)
+    if (nodes[i] == x)
+      return nodes[i + 1];
+  return NULL;
+}
+
+Node *preorder_next(Node *self, Node *x) { return next(self, x, PREORDER); }
+
+Node *inorder_next(Node *self, Node *x) { return next(self, x, INORDER); }
+
+Node *postorder_next(Node *self, Node *x) { return next(self, x, POSTORDER); }
+
+Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_is_empty) {
+  traverse(NULL, visitor, PREORDER);
+
+  assert_that(visited_count, is_equal_to(0));
+}
+
+Ensure(BinaryTree,
+       when_traversing_in_preorder_when_the_tree_has_a_single_node) {
+  Node *node = initialize(100);
+
+  traverse(node, visitor, PREORDER);
+
+  assert_that(visited_count, is_equal_to(1));
+  assert_that(visited[0], is_equal_to(100));
+  destroy(node);
+}
+
+Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_left_node) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+
+  traverse(node, visitor, PREORDER);
+
+  assert_that(visited_count, is_equal_to(2));
+  assert_that(visited[0], is_equal_to(100));
+  assert_that(visited[1], is_equal_to(200));
+  destroy(node);
+}
+
+Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_right_node) {
+  Node *node = initialize(100);
+  node->right = initialize(300);
+
+  traverse(node, visitor, PREORDER);
+
+  assert_that(visited_count, is_equal_to(2));
+  assert_that(visited[0], is_equal_to(100));
+  assert_that(visited[1], is_equal_to(300));
+  destroy(node);
+}
+
+Ensure(BinaryTree,
+       when_traversing_in_preorder_when_the_tree_has_a_left_and_right_node) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+  node->right = initialize(300);
+
+  traverse(node, visitor, PREORDER);
+
+  assert_that(visited_count, is_equal_to(3));
+  assert_that(visited[0], is_equal_to(100));
+  assert_that(visited[1], is_equal_to(200));
+  assert_that(visited[2], is_equal_to(300));
+  destroy(node);
+}
+
+Ensure(BinaryTree,
+       when_traversing_in_preorder_when_the_tree_has_multiple_levels) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+  node->right = initialize(300);
+
+  node->left->left = initialize(400);
+  node->left->right = initialize(500);
+
+  traverse(node, visitor, PREORDER);
+
+  assert_that(visited_count, is_equal_to(5));
+  assert_that(visited[0], is_equal_to(100));
+  assert_that(visited[1], is_equal_to(200));
+  assert_that(visited[2], is_equal_to(400));
+  assert_that(visited[3], is_equal_to(500));
+  assert_that(visited[4], is_equal_to(300));
+  destroy(node);
+}
+
+Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_is_empty) {
+  traverse(NULL, visitor, POSTORDER);
+
+  assert_that(visited_count, is_equal_to(0));
+}
+
+Ensure(BinaryTree,
+       when_traversing_in_postorder_when_the_tree_has_a_single_node) {
+  Node *node = initialize(100);
+
+  traverse(node, visitor, POSTORDER);
+
+  assert_that(visited_count, is_equal_to(1));
+  assert_that(visited[0], is_equal_to(100));
+  destroy(node);
+}
+
+Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_left_node) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+
+  traverse(node, visitor, POSTORDER);
+
+  assert_that(visited_count, is_equal_to(2));
+  assert_that(visited[0], is_equal_to(200));
+  assert_that(visited[1], is_equal_to(100));
+  destroy(node);
+}
+
+Ensure(BinaryTree,
+       when_traversing_in_postorder_when_the_tree_has_a_right_node) {
+  Node *node = initialize(100);
+  node->right = initialize(300);
+
+  traverse(node, visitor, POSTORDER);
+
+  assert_that(visited_count, is_equal_to(2));
+  assert_that(visited[0], is_equal_to(300));
+  assert_that(visited[1], is_equal_to(100));
+  destroy(node);
+}
+
+Ensure(BinaryTree,
+       when_traversing_in_postorder_when_the_tree_has_a_left_and_right_node) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+  node->right = initialize(300);
+
+  traverse(node, visitor, POSTORDER);
+
+  assert_that(visited_count, is_equal_to(3));
+  assert_that(visited[0], is_equal_to(200));
+  assert_that(visited[1], is_equal_to(300));
+  assert_that(visited[2], is_equal_to(100));
+  destroy(node);
+}
+
+Ensure(BinaryTree,
+       when_traversing_in_postorder_when_the_tree_has_multiple_levels) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+  node->right = initialize(300);
+
+  node->left->left = initialize(400);
+  node->left->right = initialize(500);
+
+  traverse(node, visitor, POSTORDER);
+
+  assert_that(visited_count, is_equal_to(5));
+  assert_that(visited[0], is_equal_to(400));
+  assert_that(visited[1], is_equal_to(500));
+  assert_that(visited[2], is_equal_to(200));
+  assert_that(visited[3], is_equal_to(300));
+  assert_that(visited[4], is_equal_to(100));
+  destroy(node);
+}
+
+Ensure(BinaryTree, when_traversing_inorder_when_the_tree_is_empty) {
+  traverse(NULL, visitor, INORDER);
+
+  assert_that(visited_count, is_equal_to(0));
+}
+
+Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_a_single_node) {
+  Node *node = initialize(100);
+
+  traverse(node, visitor, INORDER);
+
+  assert_that(visited_count, is_equal_to(1));
+  assert_that(visited[0], is_equal_to(100));
+  destroy(node);
+}
+
+Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_a_left_node) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+
+  traverse(node, visitor, INORDER);
+
+  assert_that(visited_count, is_equal_to(2));
+  assert_that(visited[0], is_equal_to(200));
+  assert_that(visited[1], is_equal_to(100));
+  destroy(node);
+}
+
+Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_a_right_node) {
+  Node *node = initialize(100);
+  node->right = initialize(300);
+
+  traverse(node, visitor, INORDER);
+
+  assert_that(visited_count, is_equal_to(2));
+  assert_that(visited[0], is_equal_to(100));
+  assert_that(visited[1], is_equal_to(300));
+  destroy(node);
+}
+
+Ensure(BinaryTree,
+       when_traversing_inorder_when_the_tree_has_a_left_and_right_node) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+  node->right = initialize(300);
+
+  traverse(node, visitor, INORDER);
+
+  assert_that(visited_count, is_equal_to(3));
+  assert_that(visited[0], is_equal_to(200));
+  assert_that(visited[1], is_equal_to(100));
+  assert_that(visited[2], is_equal_to(300));
+  destroy(node);
+}
+
+Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_multiple_levels) {
+  Node *node = initialize(100);
+  node->left = initialize(200);
+  node->right = initialize(300);
+
+  node->left->left = initialize(400);
+  node->left->right = initialize(500);
+
+  traverse(node, visitor, INORDER);
+
+  assert_that(visited_count, is_equal_to(5));
+  assert_that(visited[0], is_equal_to(400));
+  assert_that(visited[1], is_equal_to(200));
+  assert_that(visited[2], is_equal_to(500));
+  assert_that(visited[3], is_equal_to(100));
+  assert_that(visited[4], is_equal_to(300));
+  destroy(node);
+}
+
+Ensure(BinaryTree, when_finding_the_next_node_in_a_preorder_traversal) {
+  Node *a = initialize(100);
+  Node *b = initialize(200);
+  Node *c = initialize(300);
+  Node *d = initialize(400);
+  Node *e = initialize(500);
+
+  a->left = b;
+  a->right = c;
+  b->left = d;
+  b->right = e;
+
+  assert_that(preorder_next(a, a), is_equal_to(b));
+  assert_that(preorder_next(a, b), is_equal_to(d));
+  assert_that(preorder_next(a, c), is_equal_to(a));
+  assert_that(preorder_next(a, d), is_equal_to(e));
+  assert_that(preorder_next(a, e), is_equal_to(c));
+
+  destroy(a);
+}
+
+Ensure(BinaryTree, when_finding_the_next_node_in_a_inorder_traversal) {
+  Node *a = initialize(100);
+  Node *b = initialize(200);
+  Node *c = initialize(300);
+  Node *d = initialize(400);
+  Node *e = initialize(500);
+
+  a->left = b;
+  a->right = c;
+  b->left = d;
+  b->right = e;
+
+  assert_that(inorder_next(a, a), is_equal_to(c));
+  assert_that(inorder_next(a, b), is_equal_to(e));
+  assert_that(inorder_next(a, c), is_equal_to(d));
+  assert_that(inorder_next(a, d), is_equal_to(b));
+  assert_that(inorder_next(a, e), is_equal_to(a));
+
+  destroy(a);
+}
+
+Ensure(BinaryTree, when_finding_the_next_node_in_a_postorder_traversal) {
+  Node *a = initialize(100);
+  Node *b = initialize(200);
+  Node *c = initialize(300);
+  Node *d = initialize(400);
+  Node *e = initialize(500);
+
+  a->left = b;
+  a->right = c;
+  b->left = d;
+  b->right = e;
+
+  assert_that(postorder_next(a, a), is_equal_to(NULL));
+  assert_that(postorder_next(a, b), is_equal_to(c));
+  assert_that(postorder_next(a, c), is_equal_to(a));
+  assert_that(postorder_next(a, d), is_equal_to(e));
+  assert_that(postorder_next(a, e), is_equal_to(b));
+
+  destroy(a);
+}
+
+TestSuite *binary_tree_tests() {
+  TestSuite *suite = create_test_suite();
+
+  add_test_with_context(suite, BinaryTree,
+                        when_traversing_in_preorder_when_the_tree_is_empty);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_preorder_when_the_tree_has_a_single_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_preorder_when_the_tree_has_a_left_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_preorder_when_the_tree_has_a_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_preorder_when_the_tree_has_a_left_and_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_preorder_when_the_tree_has_multiple_levels);
+
+  add_test_with_context(suite, BinaryTree,
+                        when_traversing_in_postorder_when_the_tree_is_empty);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_postorder_when_the_tree_has_a_single_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_postorder_when_the_tree_has_a_left_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_postorder_when_the_tree_has_a_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_postorder_when_the_tree_has_a_left_and_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_postorder_when_the_tree_has_multiple_levels);
+
+  add_test_with_context(suite, BinaryTree,
+                        when_traversing_inorder_when_the_tree_is_empty);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_inorder_when_the_tree_has_a_single_node);
+  add_test_with_context(suite, BinaryTree,
+                        when_traversing_inorder_when_the_tree_has_a_left_node);
+  add_test_with_context(suite, BinaryTree,
+                        when_traversing_inorder_when_the_tree_has_a_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_inorder_when_the_tree_has_a_left_and_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_inorder_when_the_tree_has_multiple_levels);
+
+  add_test_with_context(suite, BinaryTree,
+                        when_finding_the_next_node_in_a_preorder_traversal);
+  add_test_with_context(suite, BinaryTree,
+                        when_finding_the_next_node_in_a_inorder_traversal);
+  add_test_with_context(suite, BinaryTree,
+                        when_finding_the_next_node_in_a_postorder_traversal);
+
+  return suite;
+}
+
+int main(int argc, char **argv) {
+  TestSuite *suite = create_test_suite();
+  add_suite(suite, binary_tree_tests());
+  return run_test_suite(suite, create_text_reporter());
+}

@@ -0,0 +1,50 @@
+#include "binary_tree.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static Node *nodes[32];
+static int visited_count;
+
+static void visitor(Node *node) {
+  nodes[visited_count] = node;
+  visited_count++;
+}
+
+void print_traversal(Node *tree, enum Traversal direction) {
+  visited_count = 0;
+  memset(nodes, 0, sizeof(nodes));
+
+  traverse(tree, visitor, direction);
+
+  for (int i = 0; i < visited_count; i++)
+    printf("%d ", nodes[i]->data);
+  printf("\n");
+}
+
+int main(int argc, char *argv[]) {
+  printf("=== COMP-272 - Assignment 02 - Question 01 ===\n");
+
+  Node *a = initialize(100);
+  Node *b = initialize(200);
+  Node *c = initialize(300);
+  Node *d = initialize(400);
+  Node *e = initialize(500);
+
+  a->left = b;
+  a->right = c;
+  b->left = d;
+  b->right = e;
+  inspect(a, 0);
+
+  printf("\n=== Pre order traversal ===\n");
+  print_traversal(a, PREORDER);
+
+  printf("\n=== In order traversal ===\n");
+  print_traversal(a, INORDER);
+
+  printf("\n=== Post order traversal ===\n");
+  print_traversal(a, POSTORDER);
+
+  return 0;
+}

@@ -0,0 +1,37 @@
+#!/usr/bin/make -f
+SHELL=/bin/sh
+
+CC=clang
+TEST_LIBS = -lcgreen
+
+BUILDDIR := build
+OBJS := $(addprefix $(BUILDDIR)/,binary_tree.o)
+TEST_OBJS := $(addprefix $(BUILDDIR)/,binary_tree_test.o)
+
+$(BUILDDIR)/%.o : %.c
+	$(COMPILE.c) $(OUTPUT_OPTION) $<
+
+.PHONY: all
+all: $(OBJS) $(BUILDDIR)/main.o
+	$(CC) $(OBJS) $(BUILDDIR)/main.o -o $(BUILDDIR)/program
+
+.PHONY: test
+test: $(OBJS) $(TEST_OBJS)
+	$(CC) $(OBJS) $(TEST_OBJS) $(TEST_LIBS) -o $(BUILDDIR)/test
+
+$(OBJS): | $(BUILDDIR)
+
+$(TEST_OBJS): | $(BUILDDIR)
+
+$(BUILDDIR):
+	mkdir $(BUILDDIR)
+
+.PHONY: clean
+clean:
+	rm -fr build
+
+run : all
+	./build/program
+
+run_test : test
+	cgreen-runner -c -v $(BUILDDIR)/test

@@ -0,0 +1,4 @@
+Design an algorithm for the following operations for a binary tree BT, and show the worst-case running times for each implementation:
+* preorderNext(x): return the node visited after node x in a pre-order traversal of BT.
+* postorderNext(x): return the node visited after node x in a post-order traversal of BT.
+* inorderNext(x): return the node visited after node x in an in-order traversal of BT.

@@ -0,0 +1,75 @@
+#include "btree.h"
+#include <limits.h>
+#include <stdio.h>
+
+/**
+ * A helper function used
+ * to print a visual representation
+ * of a Binary Tree
+ */
+static void inspect(BTree *tree, int level) {
+  if (!tree)
+    return;
+
+  for (int i = 0; i < level; i++)
+    printf("  ");
+
+  printf("%2d\n", tree->data);
+  inspect(tree->left, level + 1);
+  inspect(tree->right, level + 1);
+}
+
+/**
+ * A recursive function that can
+ * be used to ensure that each node in
+ * a Binary Tree satisfies the
+ * Binary Search Tree property.
+ *
+ * @param tree A tree or subtree to verify
+ * @param min the minimum value that each node must be greater than
+ * @param max the maximum value that each node must be less than.
+ * @return Returns tree when the tree is a binary search tree, otherwise false.
+ *
+ *
+ */
+static bool in_range(BTree *tree, int min, int max) {
+  if (!tree)
+    return true;
+
+  int data = tree->data;
+  if (data < min || data > max)
+    return false;
+
+  return in_range(tree->left, min, data) && in_range(tree->right, data, max);
+}
+
+/**
+ * Initializes a binary tree.
+ *
+ * @param the data to assign to the root node in the tree.
+ * @return the root of the tree.
+ */
+BTree *btree_init(int data) {
+  BTree *tree = malloc(sizeof(BTree));
+  tree->left = NULL;
+  tree->right = NULL;
+  tree->data = data;
+  return tree;
+}
+
+/**
+ * A function that determines if a binary tree
+ * is a binary search tree or not.
+ *
+ * @param tree The root of the tree to inspect
+ * @return Returns true when the tree is a binary search tree;
+ */
+bool btree_is_bst(BTree *tree) { return in_range(tree, INT_MIN, INT_MAX); }
+
+/**
+ * A helper function used to print a visual
+ * representation of the binary tree.
+ *
+ * @param tree The tree or subtree to inspect
+ */
+void btree_inspect(BTree *tree) { inspect(tree, 0); }

@@ -0,0 +1,12 @@
+#include <stdlib.h>
+#include <stdbool.h>
+
+typedef struct btree_node {
+  struct btree_node *left;
+  struct btree_node *right;
+  int data;
+} BTree;
+
+BTree *btree_init(int data);
+bool btree_is_bst(BTree *tree);
+void btree_inspect(BTree *tree);

@@ -0,0 +1,88 @@
+#include "btree.h"
+#include <cgreen/cgreen.h>
+#include <string.h>
+
+Describe(BinaryTree);
+BeforeEach(BinaryTree) {}
+AfterEach(BinaryTree) {}
+
+Ensure(BinaryTree, when_a_tree_is_NULL) {
+  assert_that(btree_is_bst(NULL), is_equal_to(true));
+}
+
+Ensure(BinaryTree, when_a_tree_has_a_single_node) {
+  BTree *tree = btree_init(100);
+
+  assert_that(btree_is_bst(tree), is_equal_to(true));
+}
+
+Ensure(BinaryTree, when_the_node_on_the_left_is_greater_than_the_root) {
+  BTree *tree = btree_init(100);
+  tree->left = btree_init(200);
+
+  assert_that(btree_is_bst(tree), is_equal_to(false));
+}
+
+Ensure(BinaryTree, when_the_node_on_the_right_is_less_than_the_root) {
+  BTree *tree = btree_init(200);
+  tree->right = btree_init(100);
+
+  assert_that(btree_is_bst(tree), is_equal_to(false));
+}
+
+Ensure(BinaryTree, when_a_node_on_the_left_subtree_is_less_than_an_ancestor) {
+  BTree *tree = btree_init(300);
+  tree->left = btree_init(100);
+  tree->left->right = btree_init(400);
+
+  assert_that(btree_is_bst(tree), is_equal_to(false));
+}
+
+Ensure(BinaryTree,
+       when_a_node_on_the_right_subtree_is_greater_than_an_ancestor) {
+  BTree *tree = btree_init(300);
+  tree->right = btree_init(500);
+  tree->right->left = btree_init(200);
+
+  assert_that(btree_is_bst(tree), is_equal_to(false));
+}
+
+Ensure(BinaryTree, when_the_tree_is_a_binary_search_tree) {
+  BTree *tree = btree_init(10);
+  tree->left = btree_init(-5);
+  tree->left->left = btree_init(-10);
+  tree->left->right = btree_init(5);
+
+  tree->right = btree_init(25);
+  tree->right->left = btree_init(23);
+  tree->right->right = btree_init(36);
+
+  assert_that(btree_is_bst(tree), is_equal_to(true));
+}
+
+TestSuite *binary_search_tree_tests() {
+  TestSuite *suite = create_test_suite();
+
+  add_test_with_context(suite, BinaryTree, when_a_tree_is_NULL);
+  add_test_with_context(suite, BinaryTree, when_a_tree_has_a_single_node);
+  add_test_with_context(suite, BinaryTree,
+                        when_the_node_on_the_left_is_greater_than_the_root);
+  add_test_with_context(suite, BinaryTree,
+                        when_the_node_on_the_right_is_less_than_the_root);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_a_node_on_the_left_subtree_is_less_than_an_ancestor);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_a_node_on_the_right_subtree_is_greater_than_an_ancestor);
+  add_test_with_context(suite, BinaryTree,
+                        when_the_tree_is_a_binary_search_tree);
+
+  return suite;
+}
+
+int main(int argc, char **argv) {
+  TestSuite *suite = create_test_suite();
+  add_suite(suite, binary_search_tree_tests());
+  return run_test_suite(suite, create_text_reporter());
+}

@@ -0,0 +1,48 @@
+#include "btree.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+void investigate(BTree *tree) {
+  btree_inspect(tree);
+  printf("Is a binary search tree? %c\n\n", btree_is_bst(tree) ? 'y' : 'n');
+}
+
+BTree *build_binary_search_tree() {
+  BTree *tree = btree_init(10);
+  tree->left = btree_init(-5);
+  tree->left->left = btree_init(-10);
+  tree->left->right = btree_init(5);
+
+  tree->right = btree_init(25);
+  tree->right->left = btree_init(23);
+  tree->right->right = btree_init(36);
+  return tree;
+}
+
+BTree *build_binary_tree() {
+  BTree *tree = btree_init(10);
+  tree->left = btree_init(0);
+  tree->left->left = btree_init(-1);
+  tree->left->right = btree_init(21);
+
+  tree->right = btree_init(25);
+  tree->right->left = btree_init(16);
+  tree->right->right = btree_init(32);
+
+  return tree;
+}
+
+int main(int argc, char *argv[]) {
+  printf("=== COMP-272 - Assignment 02 - Question 02 ===\n");
+
+  printf("Binary Search Tree\n");
+  printf("---------\n");
+  investigate(build_binary_search_tree());
+
+  printf("Binary Tree\n");
+  printf("---------\n");
+  investigate(build_binary_tree());
+
+  printf("Bye\n");
+  return 0;
+}

@@ -0,0 +1,37 @@
+#!/usr/bin/make -f
+SHELL=/bin/sh
+
+CC=clang
+TEST_LIBS = -lcgreen
+
+BUILDDIR := build
+OBJS := $(addprefix $(BUILDDIR)/,btree.o)
+TEST_OBJS := $(addprefix $(BUILDDIR)/,btree_test.o)
+
+$(BUILDDIR)/%.o : %.c
+	$(COMPILE.c) $(OUTPUT_OPTION) $<
+
+.PHONY: all
+all: $(OBJS) $(BUILDDIR)/main.o
+	$(CC) $(OBJS) $(BUILDDIR)/main.o -o $(BUILDDIR)/program
+
+.PHONY: test
+test: $(OBJS) $(TEST_OBJS)
+	$(CC) $(OBJS) $(TEST_OBJS) $(TEST_LIBS) -o $(BUILDDIR)/test
+
+$(OBJS): | $(BUILDDIR)
+
+$(TEST_OBJS): | $(BUILDDIR)
+
+$(BUILDDIR):
+	mkdir $(BUILDDIR)
+
+.PHONY: clean
+clean:
+	rm -fr build
+
+run : all
+	./build/program
+
+run_test : test
+	cgreen-runner -c -v $(BUILDDIR)/test

@@ -0,0 +1,3 @@
+Design a recursive linear-time algorithm that
+tests whether a binary tree satisfies the
+search tree order property at every node.

@@ -0,0 +1,176 @@
+#include "btree.h"
+#include "list.h"
+#include "stack.h"
+#include <stdio.h>
+
+/**
+ * A helper function used to print a visual
+ * representation of a binary tree.
+ *
+ * @param tree the tree or subtree to inspect
+ * @param level the level of the subtree
+ */
+static void inspect(BTree *tree, int level) {
+  if (!tree)
+    return;
+
+  for (int i = 0; i < level; i++)
+    printf("  ");
+
+  printf("%2d\n", tree->data);
+  inspect(tree->left, level + 1);
+  inspect(tree->right, level + 1);
+}
+
+/**
+ * Initializes an new subtree in a binary tree
+ *
+ * @param parent the parent of the new btree node
+ * @param data the data to assign to the root of the tree.
+ * @return Returns the new subtree
+ */
+BTree *btree_initialize(BTree *parent, int data) {
+  BTree *tree = malloc(sizeof(BTree));
+  tree->parent = parent;
+  tree->left = NULL;
+  tree->right = NULL;
+  tree->data = data;
+  return tree;
+}
+
+/**
+ * Converts a binary tree into a linked list
+ * using an in order traversal.
+ *
+ * @param tree The binary tree to convert
+ * @return Returns the head of a linked list.
+ */
+List *btree_to_list(BTree *tree) {
+  if (tree == NULL)
+    return NULL;
+
+  List *list = NULL;
+  Stack *stack = stack_init();
+  BTree *tmp = tree;
+
+  while (true) {
+    if (tmp) {
+      stack_push(stack, tmp);
+      tmp = tmp->left;
+    } else if (stack_size(stack) == 0) {
+      break;
+    } else {
+      tmp = stack_pop(stack);
+      if (list)
+        list_add(list, tmp);
+      else
+        list = list_initialize(tree);
+      tmp = tmp->right;
+    }
+  }
+
+  return list;
+}
+
+/**
+ * Calculates the size of a binary tree
+ *
+ * @param tree the tree to inspect
+ * @return Returns the # of nodes in the binary tree.
+ */
+int btree_size(BTree *tree) {
+  List *list = btree_to_list(tree);
+  return list ? list_size(list) : 0;
+}
+
+/**
+ * Determines if a subtree in a binary tree
+ * can be used as a scapegoat to rebalance
+ * the tree.
+ *
+ * @param tree the subtree to investigate
+ * @return Returns true then subtree can be used as a scapegoat.
+ */
+bool btree_is_scapegoat(BTree *tree) {
+  int size = btree_size(tree);
+  int parent_size = btree_size(tree->parent);
+
+  return ((size * 3) > (parent_size * 2));
+}
+
+/**
+ * Rebuilds a subtree by converting it
+ * to a list then rebuilding a binary tree.
+ *
+ * @param tree The tree to rebuild
+ * @return Returns the new binary tree.
+ */
+BTree *btree_rebuild(BTree *tree) {
+  List *list = btree_to_list(tree->parent);
+  int mid = (list_size(list) / 2) - 1;
+  List *new_root = list_get(list, mid);
+  int data = ((BTree *)new_root->data)->data;
+  BTree *new_broot = btree_initialize(NULL, data);
+
+  for (int i = 0; i < list_size(list); i++) {
+    if (i == mid)
+      continue;
+
+    int data = ((BTree *)list_get(list, i)->data)->data;
+    btree_insert(new_broot, data);
+  }
+  return new_broot;
+}
+
+/**
+ * Rebalances a binary tree starting from
+ * the bottom up.
+ *
+ * @param tree the subtree to rebalance
+ * @return Returns the new root of the binary tree.
+ */
+BTree *btree_rebalance(BTree *tree) {
+  if (!tree->parent)
+    return tree;
+
+  if (btree_is_scapegoat(tree))
+    return btree_rebuild(tree);
+
+  return btree_rebalance(tree->parent);
+}
+
+/**
+ * Inserts a new node into a binary tree.
+ *
+ * @param tree the tree to insert the new new into
+ * @return Returns the root of the tree.
+ */
+BTree *btree_insert(BTree *tree, int data) {
+  if (!tree)
+    return btree_initialize(NULL, data);
+
+  if (data <= tree->data)
+    if (tree->left)
+      return btree_insert(tree->left, data);
+    else {
+      tree->left = btree_initialize(tree, data);
+      return btree_rebalance(tree->left);
+    }
+  else if (tree->right)
+    return btree_insert(tree->right, data);
+  else {
+    tree->right = btree_initialize(tree, data);
+    return btree_rebalance(tree->right);
+  }
+
+  return tree;
+}
+
+/**
+ * A helper function used to print
+ * a visual representation of a binary
+ * tree.
+ *
+ * @param tree The root of the tree to inspect
+ */
+void btree_inspect(BTree *tree) { inspect(tree, 0); }

@@ -0,0 +1,15 @@
+#include <stdlib.h>
+#include <stdbool.h>
+
+typedef struct btree_node {
+  struct btree_node *left;
+  struct btree_node *right;
+  struct btree_node *parent;
+  int data;
+} BTree;
+
+BTree *btree_initialize(BTree *parent, int data);
+BTree *btree_insert(BTree *root, int data);
+BTree *btree_rebalance(BTree *tree);
+void btree_inspect(BTree *tree);
+int btree_size(BTree *tree);

@@ -0,0 +1,153 @@
+#include "btree.h"
+#include <cgreen/cgreen.h>
+#include <string.h>
+
+Describe(BinaryTree);
+BeforeEach(BinaryTree) {}
+AfterEach(BinaryTree) {}
+
+Ensure(BinaryTree, when_the_tree_is_NULL) {
+  BTree *tree = btree_insert(NULL, 10);
+
+  assert_that(tree, is_not_equal_to(NULL));
+  assert_that(tree->data, is_equal_to(10));
+}
+
+Ensure(
+    BinaryTree,
+    when_inserting_an_item_less_than_the_root_in_a_tree_it_creates_a_node_on_the_left_side) {
+  BTree *tree = btree_insert(NULL, 10);
+  btree_insert(tree, -5);
+
+  assert_that(tree->left, is_not_equal_to(NULL));
+  assert_that(tree->left->data, is_equal_to(-5));
+}
+
+Ensure(
+    BinaryTree,
+    when_inserting_an_item_greater_than_the_root_in_a_tree_it_creates_a_node_on_the_right_side) {
+  BTree *tree = btree_insert(NULL, 10);
+
+  btree_insert(tree, 16);
+
+  assert_that(tree->right, is_not_equal_to(NULL));
+  assert_that(tree->right->data, is_equal_to(16));
+}
+
+Ensure(
+    BinaryTree,
+    when_inserting_an_item_equal_to_the_root_in_a_tree_it_creates_a_node_on_the_left_side) {
+  BTree *tree = btree_insert(NULL, 10);
+
+  btree_insert(tree, 10);
+
+  assert_that(tree->left, is_not_equal_to(NULL));
+  assert_that(tree->left->data, is_equal_to(10));
+}
+
+Ensure(
+    BinaryTree,
+    when_inserting_multiple_items_into_a_tree_it_inserts_in_the_correct_position) {
+  BTree *tree = btree_insert(NULL, 10);
+
+  btree_insert(tree, -5);
+  btree_insert(tree, 16);
+
+  assert_that(tree->data, is_equal_to(10));
+  assert_that(tree->left->data, is_equal_to(-5));
+  assert_that(tree->right->data, is_equal_to(16));
+
+  btree_insert(tree, -8);
+
+  assert_that(tree->left->left, is_not_equal_to(NULL));
+  assert_that(tree->left->left->data, is_equal_to(-8));
+
+  btree_insert(tree, 7);
+
+  assert_that(tree->left->right, is_not_equal_to(NULL));
+  assert_that(tree->left->right->data, is_equal_to(7));
+
+  btree_insert(tree, 18);
+
+  assert_that(tree->right->right, is_not_equal_to(NULL));
+  assert_that(tree->right->right->data, is_equal_to(18));
+
+  btree_insert(tree, 6);
+
+  assert_that(tree->left->right->left, is_not_equal_to(NULL));
+  assert_that(tree->left->right->left->data, is_equal_to(6));
+}
+
+Ensure(BinaryTree, when_rebalancing_a_tree) {
+  BTree *tree = btree_insert(NULL, 1);
+  tree->right = btree_initialize(tree, 5);
+  tree->right->left = btree_initialize(tree->right, 2);
+  tree->right->left->right = btree_initialize(tree->right->left, 4);
+
+  tree = btree_rebalance(tree->right->left->right);
+
+  assert_that(tree, is_not_equal_to(NULL));
+  assert_that(tree->data, is_equal_to(2));
+
+  assert_that(tree->left->data, is_equal_to(1));
+  assert_that(tree->right->data, is_equal_to(4));
+  assert_that(tree->right->right->data, is_equal_to(5));
+}
+
+Ensure(
+    BinaryTree,
+    when_inserting_items_described_in_the_assignment_it_inserts_in_the_expected_position_in_the_tree) {
+  BTree *tree = btree_insert(NULL, 1);
+  tree = btree_insert(tree, 5);
+  tree = btree_insert(tree, 2);
+  tree = btree_insert(tree, 4);
+  tree = btree_insert(tree, 3);
+
+  assert_that(tree, is_not_equal_to(NULL));
+  assert_that(tree->data, is_equal_to(2));
+  assert_that(tree->left->data, is_equal_to(1));
+  assert_that(tree->right->data, is_equal_to(4));
+  assert_that(tree->right->right->data, is_equal_to(5));
+}
+
+Ensure(BinaryTree, when_calculating_the_size_of_the_tree) {
+  BTree *tree = btree_insert(NULL, 1);
+  tree = btree_insert(tree, 5);
+  tree = btree_insert(tree, 2);
+  tree = btree_insert(tree, 4);
+  tree = btree_insert(tree, 3);
+
+  assert_that(btree_size(tree), is_equal_to(5));
+}
+
+TestSuite *binary_search_tree_tests() {
+  TestSuite *suite = create_test_suite();
+
+  add_test_with_context(suite, BinaryTree, when_the_tree_is_NULL);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_inserting_an_item_less_than_the_root_in_a_tree_it_creates_a_node_on_the_left_side);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_inserting_an_item_greater_than_the_root_in_a_tree_it_creates_a_node_on_the_right_side);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_inserting_an_item_equal_to_the_root_in_a_tree_it_creates_a_node_on_the_left_side);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_inserting_multiple_items_into_a_tree_it_inserts_in_the_correct_position);
+  add_test_with_context(suite, BinaryTree, when_rebalancing_a_tree);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_inserting_items_described_in_the_assignment_it_inserts_in_the_expected_position_in_the_tree);
+
+  add_test_with_context(suite, BinaryTree,
+                        when_calculating_the_size_of_the_tree);
+  return suite;
+}
+
+int main(int argc, char **argv) {
+  TestSuite *suite = create_test_suite();
+  add_suite(suite, binary_search_tree_tests());
+  return run_test_suite(suite, create_text_reporter());
+}

@@ -0,0 +1,86 @@
+#include "list.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+/**
+ * Initializes a new node for a linked list.
+ *
+ * @param data The data to bind to the new node in the list.
+ * @return Returns a new linked list node
+ */
+List *list_initialize(void *data) {
+  List *node = malloc(sizeof(List));
+  node->data = data;
+  node->next = NULL;
+  return node;
+}
+
+/**
+ * Adds a new item to the tail of a linked list
+ *
+ * @param head The head of a linked list
+ * @param data The data to add to the tail of a linked list
+ * @return Returns the new tail node
+ */
+List *list_add(List *head, void *data) {
+  List *tail;
+  List *tmp = head;
+
+  while (tmp) {
+    if (!tmp->next)
+      break;
+    tmp = tmp->next;
+  }
+  tail = tmp;
+  tail->next = list_initialize(data);
+  return tail->next;
+}
+
+/**
+ * Returns a specific node by zero based index in a linked list.
+ *
+ * @param self the head of the linked list
+ * @param index the offset from the head of the node to return
+ * @return Returns the node at the specified offset or NULL.
+ */
+List *list_get(List *self, int index) {
+  if (!self || index < 0)
+    return NULL;
+
+  while (index > 0 && self) {
+    self = self->next;
+    index--;
+  }
+  return self;
+}
+
+/**
+ * Returns the total number of nodes in a linked list.
+ *
+ * @param head The head of a linked list
+ * @returns Returns the # of items in the list.
+ */
+int list_size(List *head) {
+  int i = 0;
+  for (List *tmp = head; tmp && tmp != NULL; tmp = tmp->next)
+    i++;
+  return i;
+}
+
+/**
+ * Prints a visual representation of a linked list.
+ *
+ * @param self The head of the linked list
+ * @param printer A callback function to invoke to print each item.
+ */
+void list_inspect(List *self, Printer printer) {
+  if (!self)
+    return;
+
+  printf("[");
+  while (self) {
+    printer(self->data);
+    self = self->next;
+  }
+  printf("]\n");
+}

@@ -0,0 +1,10 @@
+#include "node.h"
+
+typedef void (*Printer)(void *);
+typedef struct node List;
+
+List *list_initialize(void *data);
+List *list_get(List *from, int index);
+List *list_add(List *head, void *data);
+int list_size(List *list);
+void list_inspect(List *self, Printer printer);

@@ -0,0 +1,91 @@
+#include "list.h"
+#include <cgreen/cgreen.h>
+
+Describe(List);
+BeforeEach(List) {}
+AfterEach(List) {}
+
+Ensure(List, when_getting_head) {
+  List *head = list_initialize((void *)100);
+  assert_that(list_get(head, 0), is_equal_to(head));
+  assert_that(list_get(head, 0)->data, is_equal_to(100));
+  free(head);
+}
+
+Ensure(List, when_getting_mid) {
+  List *head = list_initialize((void *)100);
+
+  List *mid = list_add(head, (void *)200);
+  list_add(head, (void *)300);
+
+  assert_that(list_get(head, 1), is_equal_to(mid));
+  assert_that(list_get(head, 1)->data, is_equal_to(200));
+
+  free(head);
+}
+
+Ensure(List, when_getting_tail) {
+  List *head = list_initialize((void *)100);
+  List *mid = list_add(head, (void *)200);
+  List *tail = list_add(head, (void *)300);
+
+  assert_that(list_get(head, 0), is_equal_to(head));
+  assert_that(list_get(head, 0)->data, is_equal_to(100));
+
+  assert_that(list_get(head, 1), is_equal_to(mid));
+  assert_that(list_get(head, 1)->data, is_equal_to(200));
+
+  assert_that(list_get(head, 2), is_equal_to(tail));
+  assert_that(list_get(head, 2)->data, is_equal_to(300));
+
+  free(head);
+}
+
+Ensure(List, when_getting_from_empty_list) {
+  assert_that(list_get(NULL, 2), is_equal_to(NULL));
+}
+
+Ensure(List, when_getting_negative_index) {
+  List *head = list_initialize((void *)100);
+
+  assert_that(list_get(head, -1), is_equal_to(NULL));
+
+  free(head);
+}
+
+Ensure(List, when_getting_index_out_of_range) {
+  List *head = list_initialize((void *)100);
+
+  assert_that(list_get(head, 1), is_equal_to(NULL));
+
+  free(head);
+}
+
+struct Person {
+  int age;
+};
+
+Ensure(List, when_adding_a_custom_datatype) {
+  struct Person *item = malloc(sizeof(struct Person));
+  item->age = 36;
+  List *head = list_initialize((void *)item);
+
+  List *result = list_get(head, 0);
+  assert_that(result, is_equal_to(head));
+
+  struct Person *p = (struct Person *)result->data;
+  assert_that(p->age, is_equal_to(36));
+}
+
+TestSuite *list_tests() {
+  TestSuite *suite = create_test_suite();
+
+  add_test_with_context(suite, List, when_getting_head);
+  add_test_with_context(suite, List, when_getting_mid);
+  add_test_with_context(suite, List, when_getting_tail);
+  add_test_with_context(suite, List, when_getting_from_empty_list);
+  add_test_with_context(suite, List, when_getting_negative_index);
+  add_test_with_context(suite, List, when_getting_index_out_of_range);
+  add_test_with_context(suite, List, when_adding_a_custom_datatype);
+  return suite;
+}

@@ -0,0 +1,24 @@
+#include "btree.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  printf("=== COMP-272 - Assignment 02 - Question 03 ===\n");
+  printf("Tree 1: unbalanced tree\n");
+  BTree *tree = btree_insert(NULL, 1);
+  btree_insert(tree, 5);
+  btree_insert(tree, 2);
+  btree_insert(tree, 4);
+  btree_insert(tree, 3);
+  btree_inspect(tree);
+
+  printf("Tree 2: balanced tree\n");
+  tree = btree_insert(NULL, 3);
+  btree_insert(tree, 2);
+  btree_insert(tree, 4);
+  btree_insert(tree, 1);
+  btree_insert(tree, 5);
+  btree_inspect(tree);
+
+  printf("Bye\n");
+  return 0;
+}

@@ -0,0 +1,37 @@
+#!/usr/bin/make -f
+SHELL=/bin/sh
+
+CC=clang
+TEST_LIBS = -lcgreen
+
+BUILDDIR := build
+OBJS := $(addprefix $(BUILDDIR)/,btree.o list.o stack.o)
+TEST_OBJS := $(addprefix $(BUILDDIR)/,btree_test.o list_test.o stack_test.o)
+
+$(BUILDDIR)/%.o : %.c
+	$(COMPILE.c) $(OUTPUT_OPTION) $<
+
+.PHONY: all
+all: $(OBJS) $(BUILDDIR)/main.o
+	$(CC) $(OBJS) $(BUILDDIR)/main.o -o $(BUILDDIR)/program
+
+.PHONY: test
+test: $(OBJS) $(TEST_OBJS)
+	$(CC) $(OBJS) $(TEST_OBJS) $(TEST_LIBS) -o $(BUILDDIR)/test
+
+$(OBJS): | $(BUILDDIR)
+
+$(TEST_OBJS): | $(BUILDDIR)
+
+$(BUILDDIR):
+	mkdir $(BUILDDIR)
+
+.PHONY: clean
+clean:
+	rm -fr build
+
+run : all
+	./build/program
+
+run_test : test
+	cgreen-runner -c -v $(BUILDDIR)/test

@@ -0,0 +1,9 @@
+#ifndef NODE_H
+#define NODE_H
+
+typedef struct node {
+  struct node *next;
+  void *data;
+} Node;
+
+#endif

@@ -0,0 +1,3 @@
+Illustrate what happens when the sequence 1, 5, 2, 4, 3 is added to an empty
+ScapegoatTree, and show where the credits described in the proof of Lemma 8.3 go,
+and how they are used during this sequence of additions.

@@ -0,0 +1,52 @@
+#include "stack.h"
+#include <stdlib.h>
+
+Node *node_init(void *data) {
+  Node *node = malloc(sizeof(Node));
+  node->next = NULL;
+  node->data = data;
+  return node;
+}
+
+Stack *stack_init() {
+  Stack *stack = malloc(sizeof(Stack));
+  stack->head = NULL;
+  return stack;
+}
+
+int stack_size(Stack *self) {
+  if (!self || !self->head)
+    return 0;
+
+  int count = 0;
+  Node *current = self->head;
+  while (current) {
+    ++count;
+    current = current->next;
+  }
+
+  return count;
+}
+
+void *stack_peek(Stack *self) {
+  if (self->head)
+    return self->head->data;
+  return NULL;
+}
+
+void stack_push(Stack *stack, void *data) {
+  Node *node = node_init(data);
+  node->next = stack->head;
+  stack->head = node;
+}
+
+void *stack_pop(Stack *self) {
+  if (self->head) {
+    Node *tmp = self->head;
+    void *data = tmp->data;
+    self->head = self->head->next;
+    free(tmp);
+    return data;
+  }
+  return NULL;
+}

@@ -0,0 +1,11 @@
+#include "node.h"
+
+typedef struct {
+  Node *head;
+} Stack;
+
+Stack *stack_init();
+void *stack_peek(Stack *self);
+int stack_size(Stack *self);
+void stack_push(Stack *self, void *data);
+void *stack_pop(Stack *self);

@@ -0,0 +1,65 @@
+#include "stack.h"
+#include <cgreen/cgreen.h>
+#include <string.h>
+
+Describe(Stack);
+BeforeEach(Stack) {}
+AfterEach(Stack) {}
+
+Ensure(Stack, when_pushing_an_item_on_to_a_stack) {
+  Stack *stack = stack_init();
+
+  stack_push(stack, (void *)10);
+
+  assert_that(stack_size(stack), is_equal_to(1));
+  assert_that(stack_peek(stack), is_equal_to(10));
+}
+
+Ensure(Stack, when_pushing_multiple_items_on_to_a_stack) {
+  Stack *stack = stack_init();
+
+  stack_push(stack, (void *)20);
+  stack_push(stack, (void *)10);
+  stack_push(stack, (void *)50);
+
+  assert_that(stack_size(stack), is_equal_to(3));
+  assert_that(stack_peek(stack), is_equal_to(50));
+}
+
+Ensure(Stack, when_pushing_a_custom_type_on_to_a_stack) {
+  typedef struct {
+  } Item;
+
+  Stack *stack = stack_init();
+  Item *item = malloc(sizeof(Item));
+
+  stack_push(stack, item);
+
+  assert_that(stack_size(stack), is_equal_to(1));
+  assert_that(stack_peek(stack), is_equal_to(item));
+  assert_that(stack_pop(stack), is_equal_to(item));
+}
+
+Ensure(Stack, when_popping_an_item_off_of_a_stack) {
+  Stack *stack = stack_init();
+
+  stack_push(stack, (void *)20);
+  stack_push(stack, (void *)10);
+  stack_push(stack, (void *)50);
+
+  void *result = stack_pop(stack);
+
+  assert_that(stack_size(stack), is_equal_to(2));
+  assert_that(stack_peek(stack), is_equal_to(10));
+  assert_that(result, is_equal_to(50));
+}
+
+TestSuite *stack_tests() {
+  TestSuite *suite = create_test_suite();
+  add_test_with_context(suite, Stack, when_pushing_an_item_on_to_a_stack);
+  add_test_with_context(suite, Stack,
+                        when_pushing_multiple_items_on_to_a_stack);
+  add_test_with_context(suite, Stack, when_pushing_a_custom_type_on_to_a_stack);
+  add_test_with_context(suite, Stack, when_popping_an_item_off_of_a_stack);
+  return suite;
+}

@@ -0,0 +1,110 @@
+#include "hash.h"
+#include "tuple.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * Initialize a new hash table.
+ *
+ * @param size The number of buckets to allocate for the chash table.
+ * @return Returns the hash table.
+ */
+Hash *hash_init(int size) {
+  Hash *hash = malloc(sizeof(Hash));
+  hash->size = size;
+  hash->buckets = calloc(size, sizeof(Node));
+  return hash;
+}
+
+/**
+ * Computes a hash code for the given key.
+ *
+ * @param hash The hash table that the key is used in.
+ * @param key The key to produce a hash code for
+ * @return Returns a hash code for the given key.
+ */
+unsigned int hash_code(Hash *hash, int key) { return key % hash->size; }
+
+/**
+ * A function to search for a specific key in a linked list.
+ * This performs a O(n) search to find the matching key.
+ * A possible optimization would be to convert this to do a binary
+ * search for the given key using a binary search tree instead of a linked
+ * list.
+ *
+ * @param list The linked list to search for the given key
+ * @param key The key to search for in the linked list
+ * @return Returns the data associated with the given key.
+ */
+void *search(Node *list, int key) {
+  Node *current = list;
+
+  while (current) {
+    Tuple *t = current->data;
+    if (t->key == key)
+      return t->value;
+    current = current->next;
+  }
+
+  return NULL;
+}
+
+/**
+ * A function to fetch a specify value from a hash table by key.
+ *
+ * @param hash The hash table to search.
+ * @param key The key associated with the value to return
+ * @return Returns the data associated with the key or NULL if the key is not
+ * found.
+ */
+void *hash_get(Hash *hash, int key) {
+  unsigned int bucket = hash_code(hash, key);
+  Node *n = hash->buckets + bucket;
+  return (n->data) ? search(n, key) : NULL;
+}
+
+/**
+ * A function to set the value associated with a key
+ * in a hash table.
+ *
+ * @param hash The hash table to insert the key/value pair into
+ * @param key The key associated with the value to insert.
+ * @param value The value associated with the key to insert.
+ */
+void hash_set(Hash *hash, int key, void *value) {
+  unsigned int bucket = hash_code(hash, key);
+  Tuple *tuple = tuple_initialize(key, value);
+  Node *n = hash->buckets + bucket;
+
+  if (n->data)
+    list_add(n, tuple);
+  else
+    hash->buckets[bucket] = *list_initialize(tuple);
+}
+
+/**
+ * A function that pretty prints a key/value pair.
+ *
+ * @param data The Tuple to print.
+ */
+void print_tuple(void *data) {
+  Tuple *t = data;
+
+  if (t)
+    printf("(%d:%d)", t->key, t->value);
+  else
+    printf("(nil)");
+}
+
+/**
+ * Prints a visual representation of a hash table.
+ *
+ * @param hash The hash table to inspect
+ */
+void hash_inspect(Hash *hash) {
+  for (int i = 0; i < hash->size; i++) {
+    printf("%2d: ", i);
+    list_inspect(hash->buckets + i, print_tuple);
+  }
+}

@@ -0,0 +1,11 @@
+#include "list.h"
+
+typedef struct {
+  Node *buckets;
+  int size;
+} Hash;
+
+Hash *hash_init(int buckets);
+void *hash_get(Hash *hash, int key);
+void hash_set(Hash *hash, int key, void *value);
+void hash_inspect(Hash *hash);

@@ -0,0 +1,61 @@
+class List
+  attr_reader :next, :data
+
+  def initialize(data)
+    @data = data
+  end
+
+  def add(data)
+    if self.next
+      self.next.add(data)
+    else
+      @next = self.class.new(data)
+    end
+  end
+
+  def search(&block)
+    return self if block.call(data)
+
+    @next&.search(&block)
+  end
+end
+
+class MHash
+  def initialize(size = 13)
+    @size = size
+    @buckets = Array.new(size)
+  end
+
+  def [](key)
+    bucket = bucket_for(key)
+    node = @buckets[bucket]
+    return if node.nil?
+
+    found = node.search do |item|
+      item[0] == key
+    end
+    return found.data[-1] if found
+  end
+
+  def []=(key, value)
+    bucket = bucket_for(key)
+    if @buckets[bucket]
+      @buckets[bucket].add([key, value])
+    else
+      @buckets[bucket] = List.new([key, value])
+    end
+  end
+
+  private
+
+  def bucket_for(key)
+    key % @size
+  end
+end
+
+h = MHash.new
+h[8] = 'hello'
+h[21] = 'jello'
+
+puts [8, h[8]].inspect
+puts [21, h[21]].inspect

@@ -0,0 +1,80 @@
+#include "hash.h"
+#include <cgreen/cgreen.h>
+#include <string.h>
+
+Describe(HashTable);
+BeforeEach(HashTable) {}
+AfterEach(HashTable) {}
+
+Ensure(HashTable, when_initializing_a_hash) {
+  Hash *hash = hash_init(13);
+
+  assert_that(hash, is_not_equal_to(NULL));
+}
+
+Ensure(HashTable, when_getting_a_value_for_a_key_that_has_not_been_inserted) {
+  Hash *hash = hash_init(13);
+
+  assert_that(hash_get(hash, 1), is_equal_to(NULL));
+}
+
+Ensure(HashTable, when_getting_a_values_for_a_key_that_has_been_inserted) {
+  Hash *hash = hash_init(13);
+  int key = 7;
+
+  hash_set(hash, key, (void *)100);
+  assert_that(hash_get(hash, key), is_equal_to(100));
+}
+
+Ensure(HashTable, when_a_hash_collision_occurs) {
+  Hash *hash = hash_init(13);
+
+  hash_set(hash, 8, (void *)80);
+  hash_set(hash, 21, (void *)210);
+
+  assert_that(hash_get(hash, 8), is_equal_to(80));
+  assert_that(hash_get(hash, 21), is_equal_to(210));
+}
+
+Ensure(HashTable, when_inserting_multiple_items_into_the_hash_table) {
+  Hash *hash = hash_init(13);
+  int items[] = {1, 5, 21, 26, 39, 14, 15, 16, 17, 18, 19, 20, 111, 145, 146};
+  int n = sizeof(items) / sizeof(int);
+
+  for (int i = 0; i < n; i++) {
+    int key = items[i];
+    long value = key * 10;
+    hash_set(hash, key, (void *)value);
+  }
+
+  for (int i = 0; i < n; i++) {
+    int key = items[i];
+    assert_that(hash_get(hash, key), is_equal_to(key * 10));
+  }
+}
+
+TestSuite *hash_table_tests() {
+  TestSuite *suite = create_test_suite();
+
+  add_test_with_context(suite, HashTable, when_initializing_a_hash);
+  add_test_with_context(
+      suite, HashTable,
+      when_getting_a_value_for_a_key_that_has_not_been_inserted);
+  add_test_with_context(suite, HashTable,
+                        when_getting_a_values_for_a_key_that_has_been_inserted);
+  add_test_with_context(suite, HashTable, when_a_hash_collision_occurs);
+  add_test_with_context(suite, HashTable,
+                        when_inserting_multiple_items_into_the_hash_table);
+  return suite;
+}
+
+extern TestSuite *list_tests();
+extern TestSuite *tuple_tests();
+
+int main(int argc, char **argv) {
+  TestSuite *suite = create_test_suite();
+  add_suite(suite, hash_table_tests());
+  add_suite(suite, list_tests());
+  add_suite(suite, tuple_tests());
+  return run_test_suite(suite, create_text_reporter());
+}

@@ -0,0 +1,86 @@
+#include "list.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+/**
+ * Initializes a new node for a linked list.
+ *
+ * @param data The data to bind to the new node in the list.
+ * @return Returns a new linked list node
+ */
+Node *list_initialize(void *data) {
+  Node *node = malloc(sizeof(Node));
+  node->data = data;
+  node->next = NULL;
+  return node;
+}
+
+/**
+ * Adds a new item to the tail of a linked list
+ *
+ * @param head The head of a linked list
+ * @param data The data to add to the tail of a linked list
+ * @return Returns the new node tail node
+ */
+Node *list_add(Node *head, void *data) {
+  Node *tail;
+  Node *tmp = head;
+
+  while (tmp) {
+    if (!tmp->next)
+      break;
+    tmp = tmp->next;
+  }
+  tail = tmp;
+  tail->next = list_initialize(data);
+  return tail->next;
+}
+
+/**
+ * Returns a specific node by zero based index in a linked list.
+ *
+ * @param self the head of the linked list
+ * @param index the offset from the head of the node to return
+ * @return Returns the node at the specified offset or NULL.
+ */
+Node *list_get(Node *self, int index) {
+  if (!self || index < 0)
+    return NULL;
+
+  while (index > 0 && self) {
+    self = self->next;
+    index--;
+  }
+  return self;
+}
+
+/**
+ * Returns the total number of nodes in a linked list.
+ *
+ * @param head The head of a linked list
+ * @returns Returns the # of items in the list.
+ */
+int list_size(Node *head) {
+  int i = 0;
+  for (Node *tmp = head; tmp && tmp != NULL; tmp = tmp->next)
+    i++;
+  return i;
+}
+
+/**
+ * Prints a visual representation of a linked list.
+ *
+ * @param self The head of the linked list
+ * @param printer A callback function to invoke to print each item.
+ */
+void list_inspect(Node *self, Printer printer) {
+  if (!self)
+    return;
+
+  printf("[");
+  while (self) {
+    printer(self->data);
+    self = self->next;
+  }
+  printf("]\n");
+}