CS 327, Spring 2013
Information on the Second Test

The in-class part of the second test for this class will take place on Friday, April 12. The take-home part of the test will be handed out at that time.

The test will concentrate on material that we have covered since the first test. This includes topics from Chapters 4, 5, 6, 7, and 8, but we certainly didn't cover those chapters in their entirety. See the list of topics below. From the first part of the course, you still need to remember run-time and space efficiencies including how to work with Big-Theta, Big-Oh, and Big-Omega. Aside from that, material from the first part of the course will only be covered to the extent that newer material builds on it.

Here is a list of some of the things that you should know about:

be able to explain general principles/ideas of algorithmic patterns we have covered:
      dynamic programming
be able to apply certain algorithms by hand to specific instances of the problem:
      topological sort of a directed acyclic graph
      Lomuto and Hoare partitioning
      inserting items into and searching a 2-3 tree
      insertion and deletion in a heap, represented as a binary tree
      insertion, deletion, and search in an open hash table
      insertion, deletion, and search in a closed hash table using linear probing
      find a solution by dynamic programming, given the algorithm's code and formulas
understand certain algorithms and data structures well enough to explain them:
      the source-removal algorithm for topological sort
      generating all the subsets of a given set
      quickselect, for finding the k-th order statistic of an array
      quicksort, for sorting an array
      big-integer multiplication
      the efficient algorithm for finding the closest pair of points
      using presorting to efficiently test for element uniqueness in an array
      using presorting to efficiently find the intersection of two sets
      2-3 trees
      heaps, represented as binary tree and represented as array
      priority queues, implemented using heaps
      heapsort, for sorting an array
      hash tables
      Floyd's all-pairs shortest path algorithm
NOTE: You should know the run-time and/or space efficiency of many of these
NOTE: For the simpler algorithms, you might be asked to write code or pseudocode

some other terms and ideas:
      using recursion for divide-and-conquer algorithms
      databases, relational databases
      indexing in databases
      hash functions
      load factor of a hash table
      clustering in a closed hash table
      how dynamic programming relates to divide-and-conquer
      the role of "subproblems" in dynamic programs
      the edit distance problem (from dynamic programming)
      the longest common subsequence problem (from dynamic programming)