Still no syllabus handout, and we still don't have an email list.
But the course website is starting to come up:

   http://mathcs.emory.edu/~cs323000/

I hope to have a first homework out Wednesday.  Recall we'll take some
time to visit the lab (now linux based) on Friday.  Before the lab
visit, remember to visit enid.emory.edu and change your unix login
shell to bash (not ksh).

Regarding the UF topic from last time: to finish that up, I'd like to
demonstrate how to run a small code example from the book.  In fact
the textbook programs are installed in share/book/.  The main thing to
notice is that they depend on a non-standard JAR library (defining
some convenience methods, mainly for I/O).  For example:

cs323000@caribou:~/share/book$ pwd
/home/cs323000/share/book
cs323000@caribou:~/share/book$ java -cp stdlib.jar:. UF <tinyUF.txt
4 3
3 8
6 5
9 4
2 1
5 0
7 2
6 1
# components: 2
cs323000@caribou:~/share/book$ gedit UF.java &

Today we start into Chapter 2, Sorting.  I assume you have seen the
two major sorting algorithms (mergesort and quicksort) in CS171.  Both
of which run in O(n lg n) time, at least expected.  Do you remember,
that one of them has a "worst case" that is still quadratic?

I'll start with the "lower bound": no comparison based sorting
algorithm can guarantee to sort N items with few than lg(N!)
comparisons.  Note that lg(N!) is N lg N - O(N).  That is just a bit
less than N lg N (or, more than 0.9 N lg N, for large enough N).  I'll
present the argument, from pages 280-281 of your textbook.

Next we'll introduce the priority queue, and its implementation by the
binary heap.  Based on our first-day survey, I expect this topic is a
review for most of you (but not all).  We'll use these lecture notes,
from the textbook website:

   24PriorityQueues.pdf  (pages 1-24)

Probably that is all we have time for, but otherwise I'll mention
heapSort, which has some advantages over mergesort and quicksort.