The final will take place on Tuesday, May 3, 2015, at 11:00 a.m.

These are the topics that the test questions will be drawn from:

• The mathematics of sets, numbers, and functions.
• Data structure types (sets, sequences, hierachies, networks).
• How data structures are implemented (arrays, nodes, and references).
• Basics of queues, priority queues, trees, hashing, and graphs.
• Algorithm analysis:
  • Ω, O, Θ.
  • Best and worst cases.
  • Master Theorem (but also know when not to use it).
  • Effects of increasing input size, faster computers, etc.
  • P and NP.
• Numeric algorithms (multiplication, division, exponentiation, modular stuff).
• Cryptology.
• Sorting.
• Graphs: definitions, especially regarding walks.
• Classic graph algorithms.
• Algorithmic Patterns: Brute Force, Greedy, Backtracking, Branch and Bound, Dynamic Programming, Divide and Conquer, Decrease and Conquer, Las Vegas, Monte Carlo.
• Memoization.
• Informed Search.
• Hill Climbing.
• Transformations (relationships between problems), e.g. Hamilton Cycle vs. TSP.

The kinds of things you’ll be asked to do on the quiz may include:

• Give the time complexity of a code fragment.
• Answer a question that somehow deals with the relationship between certain complexity classes.
• Answer a “what if I had a faster computer?” or “what if I needed to process a larger input set?” question.
• Figure out something about a sorting algorithm... perhaps find a bug in an attempted implementation, or compare two algorithms, or identify best and worst cases.
• Answer questions about mods, logs, multiplication, etc. of really big numbers.
• Do some RSA derivations (you can use a computer to do the factoring and modular inversion computations).
• Answer questions about the effectiveness or weakness of certain ciphers, or maybe compare two different ciphers.
• Identify properties of a graph, run traversals of a graph, or find paths in a graph. This problem might require you to demonstrate knowledge of the rich graph terminology we’ve seen. It might have something to do with MSTs, shortest path, Eulerian, Hamiltonian, walks vs. paths vs. trails, number of blocks, chromatic number, vertex cover, etc.
• Illustrate, pictorially, the progression of an algorithm, for example, the steps in
  • A traversal or search
  • A run of Prim or Kruskal
  • A run of Dijkstra or Bellman-Ford
  • Heapsort
  • Priority queue loading
  • A dynamic program table expansion
  • A “search tree” expansion (with or without branch and bound)
• Distinguish Brute-Force from Uninformed Backtracking from Branch and Bound from Greedy approaches.
• Determine whether a greedy approach will work for a certain situation.

I might throw in a couple problems from Chapters 0-5 in Dasgupta, so a good way to prepare is to do some of these problems with your friends.

Also don’t forget about the Practice Problems! They might not all apply, but many will.