As a follow-up to our discussion today, here's a quick outline of what
  is in 226.  Two or three lectures might change here and there, but this
  is the material that we have been covering for some time.  I think that
  Bernard also is covering pretty much this same material.  We do
  implementations, applications, describe performance characteristics,
  and prove some theorems.  We don't expect *them* to be able to prove
  difficult theorems (that's what 423 is for) but we do expect them to 
  do some basic analysis and experiments to figure out the approximate
  asymptotic performance of the algorithms they implement.
The idea is that you should, in teaching the theory in 423, be able to
  assume that students have had some experience with these algorithms,
  so that you can use them or similar algorithms as the basis for teaching
  the theory that you want to cover.  I think that the main "overlap" that 
  we want to avoid is that CLR covers a lot of these methods from scratch, 
  and it's wasteful having students relearn all the algorithms in a 
  different notation.

-----------------------------
 1. Introduction (Union-Find)
 2. Sorting (Insertion, Selection, Shellsort)
 3. Quicksort
 4. Mergesort
 5. Priority Queues (Heaps, Binomial Queues)
 6. Radix Sorts (MSD, LSD, Radix quicksort)
 7. Searching (Symbol Table ADT, BSTs)
 8. Balanced Trees (Randomized, Red-Black, Splay)
 9. Hashing
10. Tries, TSTs
11. (midterm review or wild-card lecture)
12. String search (Knuth-Morris-Pratt)
13. grep
14. Compression (Huffman, LZW)
15. Elementary Geometric Algs (convex hull)
16. Geometric Search (2D trees, sweep line)
17. Graph ADT and representations
18. Digraphs (Warshall, DFS, strong components)
19. MSTs (Prim, Kruskal, Boruvka)
20. Shortest paths (Dijkstra, Floyd, Bellman-Ford)
21. Maxflow (Ford-Fulkerson)
22. Reduction
23. Intractability