• MIT (video)
• level order (BFS, using queue) time complexity: O(n) space complexity: best: O(1), worst: O(n/2)=O(n)

• MIT (video)
• notes: time complexity: O(n) space complexity: best: O(log n) - avg. height of tree worst: O(n)
• inorder (DFS: left, self, right)
• postorder (DFS: left, right, self)
• preorder (DFS: self, left, right)

• starts with symbol table and goes through BST applications

• Binary search tree - Implementation in C/C++ (video)
• BST implementation - memory allocation in stack and heap (video)
• Find min and max element in a binary search tree (video)
• Find height of a binary tree (video)
• Binary tree traversal - breadth-first and depth-first strategies (video)
• Binary tree: Level Order Traversal (video)
• Binary tree traversal: Preorder, Inorder, Postorder (video)
• Check if a binary tree is binary search tree or not (video)
• Delete a node from Binary Search Tree (video)
• Inorder Successor in a binary search tree (video)

• insert // insert value into tree
• get_node_count // get count of values stored
• print_values // prints the values in the tree, from min to max
• delete_tree
• is_in_tree // returns true if given value exists in the tree
• get_height // returns the height in nodes (single node's height is 1)
• get_min // returns the minimum value stored in the tree
• get_max // returns the maximum value stored in the tree
• is_binary_search_tree
• delete_value
• get_successor // returns next-highest value in tree after given value, -1 if none

• insert
• sift_up - needed for insert
• get_max - returns the max item, without removing it
• get_size() - return number of elements stored
• is_empty() - returns true if heap contains no elements
• extract_max - returns the max item, removing it
• sift_down - needed for extract_max
• remove(i) - removes item at index x
• heapify - create a heap from an array of elements, needed for heap_sort
• heap_sort() - take an unsorted array and turn it into a sorted array in-place using a max heap
  • note: using a min heap instead would save operations, but double the space needed (cannot do in-place).

• Introduction To Tries (video)
• Performance Of Tries (video)
• Implementing A Trie (video)

Know least one type of balanced binary tree (and know how it's implemented):

"Among balanced search trees, AVL and 2/3 trees are now passé, and red-black trees seem to be more popular. A particularly interesting self-organizing data structure is the splay tree, which uses rotations to move any accessed key to the root." - Skiena

Of these, I chose to implement a splay tree. From what I've read, you won't implement a balanced search tree in your interview. But I wanted exposure to coding one up and let's face it, splay trees are the bee's knees. I did read a lot of red-black tree code.

• splay tree: insert, search, delete functions If you end up implementing red/black tree try just these:
• search and insertion functions, skipping delete

I want to learn more about B-Tree since it's used so widely with very large data sets.

Self-balancing binary search tree

AVL trees

• In practice: From what I can tell, these aren't used much in practice, but I could see where they would be: The AVL tree is another structure supporting O(log n) search, insertion, and removal. It is more rigidly balanced than red–black trees, leading to slower insertion and removal but faster retrieval. This makes it attractive for data structures that may be built once and loaded without reconstruction, such as language dictionaries (or program dictionaries, such as the opcodes of an assembler or interpreter).
• MIT AVL Trees / AVL Sort (video)
• AVL Trees (video)
• AVL Tree Implementation (video)
• Split And Merge

Splay trees

• In practice: Splay trees are typically used in the implementation of caches, memory allocators, routers, garbage collectors, data compression, ropes (replacement of string used for long text strings), in Windows NT (in the virtual memory, networking, and file system code) etc.
• CS 61B: Splay Trees (video)
• MIT Lecture: Splay Trees:
  • Gets very mathy, but watch the last 10 minutes for sure.
  • Video

2-3 search trees

• In practice: 2-3 trees have faster inserts at the expense of slower searches (since height is more compared to AVL trees).
• You would use 2-3 tree very rarely because its implementation involves different types of nodes. Instead, people use Red Black trees.
• 23-Tree Intuition and Definition (video)
• Binary View of 23-Tree
• 2-3 Trees (student recitation) (video)

2-3-4 Trees (aka 2-4 trees)

• In practice: For every 2-4 tree, there are corresponding red–black trees with data elements in the same order. The insertion and deletion operations on 2-4 trees are also equivalent to color-flipping and rotations in red–black trees. This makes 2-4 trees an important tool for understanding the logic behind red–black trees, and this is why many introductory algorithm texts introduce 2-4 trees just before red–black trees, even though 2-4 trees are not often used in practice.
• CS 61B Lecture 26: Balanced Search Trees (video)
• Bottom Up 234-Trees (video)
• Top Down 234-Trees (video)

B-Trees

• fun fact: it's a mystery, but the B could stand for Boeing, Balanced, or Bayer (co-inventor)
• In Practice: B-Trees are widely used in databases. Most modern filesystems use B-trees (or Variants). In addition to its use in databases, the B-tree is also used in filesystems to allow quick random access to an arbitrary block in a particular file. The basic problem is turning the file block i address into a disk block (or perhaps to a cylinder-head-sector) address.
• B-Tree
• Introduction to B-Trees (video)
• B-Tree Definition and Insertion (video)
• B-Tree Deletion (video)
• MIT 6.851 - Memory Hierarchy Models (video) - covers cache-oblivious B-Trees, very interesting data structures - the first 37 minutes are very technical, may be skipped (B is block size, cache line size)

Red/black trees

• In practice: Red–black trees offer worst-case guarantees for insertion time, deletion time, and search time. Not only does this make them valuable in time-sensitive applications such as real-time applications, but it makes them valuable building blocks in other data structures which provide worst-case guarantees; for example, many data structures used in computational geometry can be based on red–black trees, and the Completely Fair Scheduler used in current Linux kernels uses red–black trees. In the version 8 of Java, the Collection HashMap has been modified such that instead of using a LinkedList to store identical elements with poor hashcodes, a Red-Black tree is used.
• Aduni - Algorithms - Lecture 4 (link jumps to starting point) (video)
• Aduni - Algorithms - Lecture 5 (video)
• Black Tree
• An Introduction To Binary Search And Red Black Tree

• binary trees are a 2-ary tree, with branching factor = 2
• 2-3 trees are 3-ary