Study Guide for CS 313E Test 3 (Spring 2022)

* 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 - Binary Trees, Graphs and Dynamic 
  Programming.

* The you will have to do five questions on the test. Each question
  is worth 20 points. 
  - You will be given 5 coding questions out of which you will have
    to do 3 questions.
  - You will have to solve Dijkstra's shortest path algorithm for
    a given graph in tabular form. You will not be asked to code
    Dijkstra's algorithm.
  - You will be another non-coding question with 4 parts. Here
    are possible types of questions for this question:
    - determine the minimum spanning tree and give the minimum
      weight
    - determine the Eulerian or Hamiltonian cycle in a graph
    - do a topological sort in a directed graph
    - determine if two graphs are isomorphic and if so the
      mapping of the vertices
    - determine if a tree is balanced
    - given a sorted list of numbers create a binary tree that
      is balanced

* 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 -  binary search trees and heaps. You should 
  be able to modify the data structures according to specifications - 
  like creating a create trees that are not strictly binary search 
  trees like expression trees or graphs with adjacency lists.

* 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.

* 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. 

* Determine if a graph is bipartite. Determine if two graphs are
  isomorphic and if they are give the mapping of the vertices from
  one graph to the other.

* 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.