Study Guide for CS 313E Test 3 (Fall 2020)

* This test brings together every thing we learned this semester.
  However, the emphasis will be on the new material that you were 
  not tested on - Linked Lists, Binary Trees, Heaps, Graphs and
  Dynamic Programming.

* You should be familiar with different classes of algorithms -
  brute force, greedy, divide and conquer, and dynamic programming.

* You should know the algorithms that we covered using the following 
  data structures - linked lists and binary search trees. You should 
  be able to modify the data structures according to specifications - 
  like creating a doubly linked list, create trees that are not strictly 
  binary search trees like expression trees.

* Given an infix arithmetic expression draw the binary expression
  tree representation of it. Show how to get the prefix and postfix
  expressions from that tree.

* You should be able to add to the functionality of the BinarySearchTree
  class, modify the BinarySearchTree class, or apply the BinarySearchTree
  class to solve simple problems.

* Show how to balance a binary bearch tree to create an AVL tree. 
  Show how to get the balance factor in a binary search tree and
  keep the tree balanced after insertions or deletions. You do not
  have to write code for AVL trees.

* You should be able to trace the algorithms to create a heap, add
  or delete nodes from a heap and use heap sort to sort an array.

* You must be able to obtain the adjacency matrix for a given graph.
  Or given the adjacency matrix build the graph. You should be able
  to build a graph using adjacency lists or add an Edge class to your
  graph representation. You should be able add functions to the 
  Graph class.

* You should be able to code a Graph data structure using adjacency
  lists to denote edges.

* You must be familiar and be able the trace the following graph
  algorithms - Depth First Search (DFS), Breadth First Search (BFS),
  Topological Sort, Minimum Cost Spanning Tree using Kruskal's and
  Prim's algorithm, and Dijkstra's Single Source Shortest Path 
  algorithm. Determine if there is an Eulerian path (cycle) in a 
  graph and trace that Eulerian path (cycle). Trace (not code) the
  Hamiltonian path (cycle) in a graph. 

* Given the description of a new data structure you should be able 
  to write the class to represent it.

* Given a Dynamic Programming problem you should be able to represent
  its solution in tabular form and in code.

* The following are topics that will be good to know but you will not
  be tested directly.

* You should know the following sorting algorithms and their efficiency 
  - selection sort, bubble sort, insertion sort, merge sort and
  quick sort. You should be able to trace each of the algorithms
  for a given array.

* You should be able to apply binary search and merge algorithms.

* Using recursion, you should be able to do permutation and
  combination and back tracking. But you will be responsible for
  using recursion on binary trees and graphs. 

* You should be able to use a hash function and hash using single
  probing, quadratic probing, and double hashing.