Notes for topics covered at the review session:

Note these topics were chosen by the students attending the
session.

The notes here are just an overview, but can be turned into
good suggestions for practice problems if you want to study
with your friends / try testing yourself on these topics
before looking up some of the answers.


~~~B Trees~~~
* "sorted" trees just like AVL and BST
* huge nodes with multiple (M - 1) keys as fenceposts for
  each branch node
* nodes are huge (1 page / lookup size amount) to maximize
  efficiency for disk AKA far away memory / inefficient
  look-ups.
* use last quarter's slides on B-Trees for the alorithm for
  put (slide 48/85), we went over an example of splitting
  nodes (nodes need to maintain the fixed # of L and M for
  every node to maintain the optimized memory look ups)

~~~QuickSort~~~ 
* strategies for picking a pivot (1st thing, median of 3)
* run through the fact it can be done in place (advantage
  over mergesort)
* ran through example of execution

~~~Sorts (Selection, Insertion, Merge, Quick, Heap)~~~
* drew out table of comparisons for best case runtime, worst
  case runtime (when best/worst occur and when to use and
  when to avoid), in place, and stable
* reminder that main take aways for final: want to be able to
  use knowledge (not just reproduce mechanical procedures).
  Don't forget to note and consider: When do we use certain
  algorithms (in this case, the specific sorts)? 

~~~Graph algorithms~~~
* BFS / DFS, overview of what they are / common uses 
  basically graph traversals in general to visit all the
  nodes / find things. You can also use BFS to find the
  fewest edge path to notdes. Lots of applications to real
  world graph problems / set ups, try doing some graph
  algorithm questions with them)
* Dijkstra's - ran through an example on made up graph
* Topological sort - ran through example (from section #10)

* reminder: probably is good to know what types of graphs
  you can run these algorithms on (Dijkstras = weighted
  graphs, topological on sorted graphs) and remember some
  common applications.

~~~Testing and Debugging~~~

Find as many bugs as you can with the following partial
implementation of ArrayHeap (0-based indexing and 4 children
min heap)

public class ArrayHeap ... {
    private T[] heap;
    private int size;
    ...

    public void insert(T item) {
        this.heap[size] = item;
        size++;
        this.percolateUp(this.size - 1);
    }

    private void percolateUp(int index) {
        int parent = index - 1 / 4;
        while (this.heap[index] < this.heap[parent]) {
            this.heap[index] = this.heap[parent];
            this.heap[parent] = this.heap[index];
            index = parent;
        }
    }
}

Explain and draw some sample internal arrays and sample
insert() calls.  Describe where / when a bug will show
itself and how that will affect the result. (You can ignore
the major bugs like (SPOILERS ahead so only read if you've
done the previous question)
...

...

...


...

compareTo "bug", just assume it actually uses compareTo
correctly)

Get some practice writing unit test names. Try to write as
many cases (and matching input + method call setups) as you
can that would be helpful in testing the insert method, and
debugging in general.

~~~ MSTs ~~~
* reviewed execution of Prim's and Kruskal's. Section 9
  Problem 1. Be sure to review common applications / high
  level meaning of an MST / try to come up with a real-world
  graph representation where generating an MST would be
  useful.

~~~ Recurrences ~~~
* did Section 10 problem 1b together.