Graphic by Keith Ohlfs

CS111, Wellesley College, Fall 2001 Problem Set 9 Due on Wednesday, November 28, at 11pm

How to turn in this Problem Set

Part I: Selection Sort using Vectors

 public static int minIndexBetween (int [ ] a, int lo, int hi) {
  // Return the index of the minimum integer in a[lo..hi], or -1 if the segment is empty
      int minVal = Integer.MAX_VALUE;
      int minInd = -1;
      for (int i = lo; i <= hi; i++) {
           if (a[i] < minVal) {
                minVal = a[i];
                minInd = i;
           }
      }
      return minInd;
 }

 public static void swap (int [ ] a, int i, int j) {
  // Swap the contents of a[i] and a[j]
      int temp = a[i];
      a[i] = a[j];
      a[j] = temp;
 }

 public static void selectionSort (int [ ] a) {
      for (int i = 0; i < a.length-1; i++) {
           swap(a, i, minIndexBetween(a, i, a.length-1));
      }
 }
 

As always, you should write a draft of your methods on paper, then add them gradually to a working program, testing each method in isolation before continuing.

 public static int indexOfMinStringBetween (Vector vec, int lo, int hi) {
  // vec is assumed to be a Vector of Strings which contains valid Strings in positions lo..hi at least
  // Returns the index of the minimum integer in vec[lo..hi], or -1 if the segment is empty
  // Uses the String instance method compareTo()
      String minVal = "zzzzz";
      int minInd = -1;
 
 
 
 
 

 }
 

 public static void swap (Vector vec, int i, int j) {
  // vec is any Vector with valid Objects (not necessarily Strings) in positions i and j
  // Swaps the contents of vec[i] and vec[j]
 
 
 
 
 

 }
 

 public static void selectionSort (Vector vec) {
  // vec is assumed to be a Vector of Strings
  // sorts vec into alphabetical order through selection sort, using the Vector version of swap
 
 
 
 
 

 }

Notes:

• Use the String instance method compareTo() to compare Strings in the indexOfMinStringBetween() method. Recall that the invocation x.compareTo(y) returns a negative int if String x is alphabetically less than String y, it returns 0 if the two Strings are the same, and it returns a positive int if String x is alphabetically greater than String y.
• Keep your code as close as possible to that described above for arrays of ints. Make changes only as needed to deal with Strings instead of ints as the basic element type, and Vectors instead of arrays as the container type. Refer to the Vector contract available on the lectures page for information about the basic Vector instance methods available.
• A correct implementation is being provided to you in the class file StringVectorOpsSolns.class. Note that the Java source code is not being provided, as this is the task that you should carry out here. Test your code by opening the test applet in StringVectorOpsTest.html . You may comapre the results with the solutions by running the applet in the file StringVectorOpsTestSolns.html .

Part II: The Day-to-Day Database Crisis!

The Features of the DatabasePrograms

If you press the Load DB File button, you will be prompted to select a database file using the usual Macintosh file dialog mechanism. All files ending in the extension .db are database files.

Loading Databse Files:

Each personnel entry has four fields: a last name, a first name, a middle name or initial (which may be empty), and an email name. An entry may be selected by clicking on it. At most one entry can be selected at any one time.

The other buttons manipulate the entries as described below.

• Add: This button allows the user to add a single person to the data base. When pressed, a window appears with text fields for First name, Middle name, Last name and Email address, to be filled in by the user.
• Remove: This button removes the selected entry from the database.
• Print: This button displays the current database in the stdout window.
• Sort: This allows the user to sort the entries in the database alphabetically by a given field. When pressed, the user is prompted to sort by First name, Middle name, Last name, or Email address.

The Database Class Interface

The Database class has the following interface:

Constructor:

public Database()
   Create an empty database (one that contains no persons).

Instance Methods:

public int size()
   Return the number of persons in the database.
    
public void clear()
   Make this database empty. 
    
public void add(Person p)
   Add person p to the end of this database. 
    
public void remove(String s)
   Remove the person with description string s from this database.
    If no person in the database has description string s, do nothing. 
    (The description string of a Person object is the entry string that 
    appears in the database window. This string is produced by the 
   String toString() method of the Person class. The 
   boolean hasString (String s) method on the Person 
    class is used to test if a person has a given description string.)
    
public void sort (Comparator comp)
   Sort the entries of the database according to the comp object. A
   Comparator object specifies the ordering of two Person objects via a
   boolean lessThan (Person p1, Person p2) method. 
    
public void print()
   Display the entries of the database in the stdout window. 
        
public void print(PrintStream ps)
   Write the entries of the database to the print stream ps. 
    This method is used to save databases to a file. 
        
public String [ ] entryList()
   Return an array of description strings for the entries of the database.
    The description strings have the same order as the database entries.

The Database Class Implementation

• Suppose the current database contains n entries.
• Create a new array (newPeople) that has length equal to n+1.
• Copy the elements of people[0..n-1] into newPeople[0..n-1].
• Store p into the last slot of newPeople.
• Replace the old array by the new array.

• Suppose the current database contains n entries.
• Determine the index i at which the person with description string s resides.
• Create a new array (newPeople) that has length equal to n-1.
• Copy the elements of people[0..i-1] into newPeople[0..i-1].
• Copy the elements of people[i+1..n-1] into newPeople[i..n-2].
• Replace the old array by the new array.

The purpose of part A of this problem is to explore an alternative representation of databases that makes add and remove more efficient. Part B explores the use of Vectors as the basis for yet another implementation, one that is rather convenient from the programmer's point of view.
 
 

Part A: An Alternative Database Representation Using Arrays

• Create a new array that is 8 elements long.
• Copy the current array of 4 elements into the new array.
• Add the 5th person to the new array.
• Make the new array the current array.

The remove method can be implemented as follows:

• Suppose the current database contains n entries.
• Determine the index i at which the person with description string s resides.
• Shift the elements of people[i+1..n-1] leftward into the slots people[i..n-2].

Note that the number of entries in this strategy is no longer equal to the length of the people array. To keep track of the database size, a database object must have an additional instance variable (call it count) that counts the number of entries in the database. The following invariant should be preserved by all the database operations:

• The slots people[0..count] should contain the Person objects representing the entries of the database. The slots[count+1..people.length-1] have unspecified contents -- they may be null, or may contain Person objects that will be ignored by the database program

1. Download the Database folder.
2. Open the project Database.mcp.
3. Open Database.java by double clicking on the icon in the project window. This file contains the current version of the database with the inefficient (but correct) implementation of all the methods. Use this implementation as the example of how the database behaves on various data.
4. Write your code for the alternative array implementation in the file DatabaseArrays.java which contains definition of the class DatabaseArrays.class.
5. Test your code by moving the file DatabaseArraysWorld.html to the topmost position in Link Order in the project folder.
6. You can run the original implementation by moving the file DatabaseWorld.html to the topmost position in Link Order. This may be useful for testing your code.

Contrary to the earlier instructions on this web page, you don't need to rename any files or methods.

For this problem, you will need to accomplish the following tasks:

1. Implement the DatabaseArrays() constructor of the class DatabaseArrays. The initial people array should have length 4.
2. Implement the size() method. You can test this method using the Print button, which prints out the size of the database along with the entries.
3. Implement the clear() method. This should not change the size of the people array.
4. Implement the add(Person p) method as outlined above. This should double the size of the people array only when the array is full of valid entries. You may wish to insert a call to System.out.println that indicates every time the array size is doubled. You can test this method via the Add button. You can also test add(Person p) and clear() together using the Load DB File button. This clears the database and adds the entries from the file one by one. You should try loading all the provided .db files.
5. Implement the remove() method as sketched above. This method should not change the size of the people array. You can test this method via the Remove button.
6. It is not necessary to modify any other methods other than the ones mentioned above. As part of your problem set, you should include a brief explanation why it is not necessary to modify any of the other methods.

Part B: An Alternative Database Representation Using Vectors

1. Write your code in the file DatabaseVectors.java which contains the definition of theclass DatabaseVectors.class: the databse implementation using vectors.
2. To run your code, move the file DatabaseVectorsWorld.html to the topmost position in Link Order.
3. You can run the original implementation by moving DatabaseWorld.html to the topmost position in Link Order.

For this problem, you will need to accomplish the following tasks:

1. Implement the DatabaseVectors() constructor.
2. Implement the size() method. You can test this method using the Print button, which prints out the size of the database along with the entries.
3. Implement the clear() method. This method is allowed to change the size of the people Vector. There is a convenient Vector method that you can use to implement clear() but that does not appear in the Vector contract discussed in lecture. To find this additional method, consult the Vector class documentation as described below. However, feel free to provide a different implementation of clear() if you prefer.
4. Implement the add(Person p) method. You can test this method via the Add button. You can also test add(Person p) and clear() together using the Load DB File button. This clears the database and adds the entries from the file one by one. You should try loading all the provided .db files.
5. Implement the remove() method as sketched above. This method isallowed to change the size of the people Vector. You can test this method via the Remove button.