Note that you've already covered a number of algorithms and related topics in prerequisite courses:

• CS 2123 (formerly CS 1723), Data Structures.
  • Elementary data structures: stacks, queues, linked lists.
  • Searching: linear search, binary search, hashing.
  • Sorting: elementary sorts, quick sort, heaps, heap sort and priority queues.
  • Trees: binary trees, binary search trees.
  • Huffman code.
  • Recursion.
  • Graphs.

• CS 2233, Discrete Mathematical Structures.
  • Logic.
  • Proof methods, esp. mathematical induction.
  • Basic discrete structures, esp. sequences, summations.
  • Graphical structures (relations, graphs, trees).
  • Order notation (O, Θ, Ω).
  • Recurrences (recursive definitions and algorithms, master theorem).
  • Automata (finite state machines, context-free grammars, Turing machines).

• CS 3333, Mathematical Foundations of Computer Science.
  • Integers (mod, gcd, primes, binary representations).
  • Vectors and matrices.
  • Some combinatorics.
  • Some probability and statistics.

We will seldom use the Java (or C, or C++) libraries for our data structures, but instead write them from scratch.

1. Elementary data structures (review, interspersed where needed):
   1. Stacks, queues.
   2. Linked lists.
   3. Binary trees.

2. Growth of functions, recurrences (partial review, interspersed where needed):
   1. Asymptotic bounds, notation.
   2. Recurrences.
   3. Master theorem.

3. Recursion (partial review in the second recitation)

1. Introduction:
   1. Exponentiation (integer exponent), slow way, two different fast ways.
   2. Performance of fast exponentiation, "big-O" notation. Other order notations.
   3. Proof of correctness of exponentiation.

2. Divide-and-conquer:
   1. Binary search.
   2. Ternary search.
   3. Strange search.

3. Quick sort:
   1. Basic algorithm.
   2. Randomized algorithm.
   3. Besting an opponent who has arbitrary computing power.

4. Heap sort:
   1. Heaps.
   2. Basic algorithm.
   3. Priority queue.

5. Strassen's matrix multiplication:
   1. Basic approach.
   2. Solving the recurrence.

6. Binary trees (partly review):
   1. Binary search trees
   2. Representation of a tree (rooted, with unbounded branching) as a binary tree.
   3. Traversals, searches, insertion.
   4. Balanced binary trees (AVL, Red-Black), without tears.

7. Dynamic programming:
   1. Memoization.
   2. Matrix-chain multiplication.
   3. Subset-sum problem.
   4. Line breaks for optimal paragraph formatting.

8. Greedy algorithms:
   1. Translating to Roman numerals.
   2. Making change.

9. Graphs and graph algorithms:
   1. Introduction to graphs.
   2. Data structures for graphs: adjacency-list versus adjacency-matrix.
   3. Breadth-first, depth-first searches. Topological sort.
   4. Shortest paths (some flavor).
   5. Minimum spanning trees.

10. Topics from Cryptography (time permitting)
    1. Origins of public-key cryptography.
    2. RSA cryptosystem, and necessary algorithms.

11. NP-completeness:
    1. Definitions, decision problems versus optimization problems.
    2. Circuit-satisfiability and the main theorem.
    3. Examples, reductions.
    4. Subset-sum and strong NP-completeness.
    5. Approximation algorithms.

12. Undecidable problems:
    1. Models of computation, Turing completeness, Church-Turing Thesis.
    2. Halting problem, word problem undecidable.
    3. Other problems, discussion.

These are covered in a separate page: Weird Topics.