Outline of Class 23: Sorting without swapping

Miscellaneous

• Printing HTML: I've asked a number of you how to print HTML files on the HP's so that the documents have running headers and footers. I'll note that my search is now over. I've installed html2ps which does all I wanted, and more. You can find it at /u2/rebelsky/bin/html2ps. The command I used to print this was (approximately)
  % html2ps -D url | psnup -2 | lp
  Feel free to email me questions about usage.
• Putnam Exam: The 58th Annual William Lowell Putnam Mathematical Competition will be held on Saturday, December 6, 1997. This competition is open to undergraduates in colleges and universities of the United States who have not yet received a college degree. The competition is designed to stimulate a "healtful rivalry in mathematical studeis" among undergraduates. The exam will be given on campus in two periods of three hours each -- 9:00 a.m. to 12:00 noon and 2:00 to 5:00 p.m. Students who wish to register for the exam should tell Charles Jepsen by Friday, October 10. See him for additional information about the exam.
• Convocation: I'd recommend going to this weeks Scholars' Convocation, which has a talk by the CEO of Lucent, a 1968 Grinnell grad and loyal alum. There's also an evening panel on competitiveness on Thursday.
• Grading: A workshop I signed up for this coming weekend expects me to have a draft grant proposal, so I'll be spending much of my week on that, rather than on grading your assignments. Sorry, but I am proposing to get more equipment for the department, so it benefits you in the long run.
• Example: An example of radix sort using arrays of integers can be found at Examples/RadixSort.java.
• JavaScript Session: A few of you have asked me to teach a workshop on JavaScript. I'm still trying to determine a good weekend day to hold such a workshop. Send me email if you're interested in attending (with a suggestion of what days would be good).

Faster sorting methods

• Can we do better than O(n*log_2(n))?
• As I've tried to make clear, it depends on our basic operations.
• If you are restricted to compare and swap, it turns out that you can't do better than n*log_2(n) steps. Why not? A careful analysis will show you that if you use fewer steps, you won't have been able to compare each element to every other element (directly or indirectly). If there are two elements that were never compared, they may not be in the correct place.
• So, can we throw away our comparisons of elements and swaps?
• (Yes, but it doesn't seem to be covered in the book.)

Bucket Sort

• If we know that the elements in our array are in a restricted range, we can do a sort that array without comparing and swapping, if we're willing to use some extra space.
• In bucket sort, we build a set of buckets that correspond to the range of elements. We then step through our array, copying or moving each element to the appropriate bucket. When we're done copying elements, we can simply pull them out of the buckets in order (since the buckets are ordered).
• What is the running time? O(n+m), where n is the number of elements and m is the number of buckets.
• What is the extra space requirement? O(m).
• A simple variation is to have bigger buckets, and recursively sort each bucket. This can save some space, but may then require extra time. (In the extreme case, we only use two buckets in each sort or subsort, giving us something close to quick sort.)
• One implementation question that arises is how to implement the buckets, given that the same bucket may hold multiple elements. We'll leave that question to the future.

Radix Sort

• If each object to be sorted can be represented as a sequence of values (e.g., a sequence of digits in a decimal number, a sequence of characters in words, a sequence of bits in the binary representation of the object) and sorting can be based on that sequence, then it is possible to sort based on those sequences.
• In radix sort, one repeatedly partitions the objects based on one of the elements of the sequence, moving from least significant to most significant element of the sequence. After each partition, we glue the partitions back together, smallest to largest.
• Each partitioning must maintain the previous partitioning within each new partition. E.g., if a precedes b after the first partitioning, and a and b end up in the same group in the second partitioning, then a must precede b in its group.
• Most often, we simply use bits for the partitioning, as these are easiest to check and use.
• In psuedo-Java, for the boolean case

  public static void radixSort() {
    radixSort(v,0);
  } // radixSort
  /**
     Radix sort the vector, starting with the bth-least significant
     bit.
     pre: 0 <= b < # of places in the sequence representation of
          the data type
     pre: this vector has been radix sorted for all 0 <= i < p
     post: this vector is radix sorted
    */
  public static void radixSort(place p) {
    // Base case, we've run out of bits
    if (p == PLACES_IN_ELEMENT) return;
    // Recursive case, partition and move on to the next bit
    splitAndJoin(b);
    return radixSort(b+1);
  } // radixSort
   
  /**
     Split the elements at the pth position
     pre: 0 <= b < # of places in the sequence representation of
          the data type
     post: For all i, the pth place in v[i] <= the pth place in v[i+1]
    
  /
  public static void splitAndJoin(int p) {
    // Create the set of buckets
    Vector[] buckets = new Vector[POSSIBLE_PLACE_VALUES];
    for(int i = 0; i < POSSIBLE_PLACE_VALUES; ++i)
      buckets[i] = new Vector();
    // Paritition the vector
    for(int i = 0; i < size(); ++i) {
      buckets[elementAt(i).placeValue(p)].addElement(elementAt(i));
    }
    // Put 'em back together
    setLength(0);
    for(int i = 0; i < POSSIBLE_PLACE_VALUES; ++i) {
      addElements(buckets[i]);
    }
  } // splitAndJoin
  

• What's the running time? Well, there are O(l) rounds, where l is the number of positions in the sequences. In each round, we spend O(n) time taking stuff out of the vector (assuming that we can append to each bucket in constant time) and O(m+n) time putting stuff back into the vector. That gives an overall running time of O(l*(m+n)).
• However, we can often call l and m constants (e.g., for integers, l is always 32 and m is always 2), so that's a running time of O(n).
• Space usage is O(n+m), for the temporary buckets.

Other sorting algorithms

• As we learn some more data structures, we'll also learn some more sorting methods that depend on those data structures. One to look forward to is heap sort.

Lists

• Lists are among the simplest of data structures.
• Like arrays and vectors, they are used for storing and retrieving data.
• Unlike arrays and vectors, they do not necessarily guarantee constant time access to each element.
• However, they do (usually) guarantee constant time insertion of elements (given a few restrictions on where you add the element).
  • Some list implementations guarantee constant time insertion at the front of the list.
  • Some list implementations guarantee constant time insertion at the end of the list.
  • Some list implementations gurantee constant time insertion at any position of the list you've moved to.
• As before, we can begin to define lists by the operations we permit. What are reasonable operations?
  • Creation of new, empty, lists.
  • Insertion of elements in the list.
  • Deletion of elements from the list.
  • Test emptiness of the list.
  • Test containment of objects in the list.
  • Modification of elements in the list.
  • Determine size of the list.
  • Extract the first element of the list. This is often refered to as the head or car of the list.
  • Extract all but the first element of the list. This is often refered to as the tail or cdr of the list.

Implementation Issues

• There are a number of ways in which we can implement lists, and these implementations govern the cost of the various operations.
  • Most programmers expect that insertion and testing for emptiness are constant time operations. Certain kinds of deletion are also constant time (e.g., delete the first element).
• There are a number of hidden issues to consider when designing implementations. For example, when we ask for the tail of a list and then modify that tail, do we modify the original list?
• Here's one example in Java form

  // Assume l is the list 3,6,8,32
  lprime = l.tail();
  lprime.addToHead(new Integer(5));
  System.out.println(l.tail().head());
  

• Here's a similar example that might have different results (at least in terms of our understanding of what modifications mean)

  // Assume l is the list 3,6,8,32
  lprime = l.tail();
  lprime.remove(new Integer(8));
  System.out.println(l.contains(new Integer(8)));
  

• In designing our implementations, we will need to consider tradeoffs between efficiency, memory usage, simplicity of implementation, and ambiguity.