Module 3: Sorting

class Person {

    // Some data:
    String firstName;
    String lastName;
    int birthYear;
    

    // This is called a constructor:

    public Person (String firstName, String lastName, int birthYear)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.birthYear = birthYear;
    }


    // A comparison method to allow two Person instances to be compared.

    public boolean lessThan (Person p)
    {
        // Compare the birthyear inside this instance (where we are executing)
        // with the birthyear of the parameter instance.
        if (birthYear < p.birthYear) {
            return true;
        }
        else {
            return false;
        }
    }
    
} // end-of-Person




public class ObjectSortExample {

    public static void main (String[] argv)
    {
        // Make space for 10 person pointers.
        Person[] someKennedys = new Person [10];

        // Each array location is itself an object pointer. We
        // need to assign actual object instances using the new operator.
        someKennedys[0] = new Person ("Patrick", "Kennedy", 1858);
        someKennedys[1] = new Person ("Joseph", "Kennedy", 1888);
        someKennedys[2] = new Person ("Rose", "Fitzgerald", 1890);
        someKennedys[3] = new Person ("Joseph", "Kennedy", 1915);
        someKennedys[4] = new Person ("John", "Kennedy", 1917);
        someKennedys[5] = new Person ("Jacqueline", "Bouvier", 1929);
        someKennedys[6] = new Person ("Robert", "Kennedy", 1925);
        someKennedys[7] = new Person ("Edward", "Kennedy", 1932);
        someKennedys[8] = new Person ("Caroline", "Kennedy", 1957);
        someKennedys[9] = new Person ("Maria", "Shriver", 1955);

        System.out.println ("Unsorted: ");
        print (someKennedys);

        sort (someKennedys);

        System.out.println ("\nSorted: ");
        print (someKennedys);
    }


    static void print (Person[] people)
    {
        for (int i=0; i < people.length; i++) {
            System.out.println (people[i].firstName + " " + people[i].lastName + " (b. " + people[i].birthYear + ")");
        }
    }
    

    static void sort (Person[] people)
    {
        // Selection Sort.

	for (int i=0; i < people.length-1; i++) {
	    Person min = people[i];
	    int pos = i;
	    for (int j=i+1; j < people.length; j++) {
                // Compare j-th person with best so far.    
		if ( people[j].lessThan (min) ) {
		    min = people[j];
		    pos = j;
		}
	    }

	    // Swap.
	    Person temp = people[i];
	    people[i] = people[pos];
	    people[pos] = temp;
	}
    }

} // end-of-ObjectSortExample

You can easily extend the above exercise to the entire deck. Here are the first few steps when sorting the deck as a whole:

• Look at the first card to determine the color of it's suit.
  • If the card is a red suit, place the card in a pile to the left
  • If the card is a black suit, place the card in a pile to the right.
  • Repeat this process for all cards in your deck until all cards are either in the red pile or the black pile.
• Look at the first card in the black pile
  • If the card is a Spade, place the card in a new pile to the left.
  • If the card is a Club, place the card in a new pile to the right.
  • Repeat this process for all cards in the black pile until all black cards are either in the Spade pile or the Club pile. For the red cards, divide them based on whether they are a Heart or a Diamond.
• Use the same process as sorting the Spades above to sort each individual suit

Key ideas in Quicksort:

• Consider the array

        [51, 24, 63, 73, 42, 85, 71, 41, 87, 32]
      

  and the first element '51'.

• Suppose we place the elements less than '51' to the left and those greater to the right of it:

        [24, 42, 41, 32]   51   [63, 73, 85, 71, 87]
      

• Then, suppose we magically sort the left array independently:

        [24, 32, 41, 42]   51   [63, 73, 85, 71, 87]
      

• Next, suppose we magically sort the right array:

        [24, 32, 41, 42]   51   [63, 71, 73, 85, 87]
      

• Then, we can piece together the final result:

        [24, 32, 41, 42,   51,   63, 71, 73, 85, 87]
      

• Key insight: sorting the smaller arrays (left and right) is just like sorting a larger array
       ⇒ We can apply the same idea recursively.

• Thus, the code is going to look like this:

      static void quickSortRecursive (int[] data, int left, int right)
      {
          if (left < right) {
  
              // Partition to find the "right place" for the leftmost element.
              int partitionPosition = quickSortPartition (data, left, right);
  
              // Recurse on the left side:
              quickSortRecursive (data, left, partitionPosition-1);
  
              // Recurse on the right side:
              quickSortRecursive (data, partitionPosition+1, right);
          }
          // Else: left==right so we're done.
      }
      

• We won't need to build separate arrays if we can somehow do everything in one array:
  • When we "partition" the array, we use the leftmost element and find the "right place" for it:

            [24, 42, 41, 32, 51, 63, 73, 85, 71, 87]        // Inside original array
                             ^
                          partition position = 4                            
          

  • Then, all we need are the limits on each side:

            [24, 42, 41, 32, 51, 63, 73, 85, 71, 87]        // Inside original array
             ^           ^                                  // Left array limits
            left=0       right=3
          

    and

            [24, 42, 41, 32, 51, 63, 73, 85, 71, 87]        // Inside original array
                                 ^                ^         // Right array limits
                                 left=6         right=9
          

• Thus, if we can write the recursive method to work with "left" and "right" indices to delineate a portion of the array, we can use the same array.

import java.util.*;

public class QuickSort {

    public static void main (String[] argv)
    {
        int[] testData = {51, 24, 63, 73, 42, 85, 71, 41, 87, 32};
        
        System.out.println ("Before: " + Arrays.toString(testData));
        
	quickSort (testData);

        System.out.println ("After: " + Arrays.toString(testData));
    }


    static void quickSort (int[] A)
    {
        quickSortRecursive (A, 0, A.length-1);
    }
    

    static void quickSortRecursive (int[] data, int left, int right)
    {
        if (left < right) {

            // Partition to find the "right place" for the leftmost element.
            int partitionPosition = quickSortPartition (data, left, right);

            // Recurse on the left side:
            quickSortRecursive (data, left, partitionPosition-1);

            // Recurse on the right side:
            quickSortRecursive (data, partitionPosition+1, right);
        }
        // Else: left==right so we're done.
    }


    static int quickSortPartition (int[] data, int left, int right)
    {
        if (left == right)
            return left;
        int partitionElement = data[right];
        int currentSwapPosition = right; 
        for (int i=right-1; i>=left; i--) {
            // Examine everything between left and right-1 inclusive.
            if (data[i] > partitionElement) {
                // Switch with swap position
                currentSwapPosition--;
                swap (data, currentSwapPosition, i);
                // Shift swap position rightwards:
            }
        }
        // Last one:
        swap (data, currentSwapPosition, right);
        return currentSwapPosition;
    }


    static void swap (int[] data, int i, int j)
    {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

}

In-Class Exercise 6: Can you identify where in the code comparisons are actually made? Modify QuickSort2.java to count the number of comparisons. Then plot the results along with the other sort algorithms in Exercise 5 above.

Brute Force and Divide and Conquer

Selection, Bubble, and Insertion Sorts belong to a class of algorithms that employ a brute force strategy. A brute force strategy is typically based on an iterative approach that repeatedly operates on the same data. A brute force strategy will typically focus on solving the smallest part of the problem in one step and then repeat those steps over and over until it reaches an overall solution.

Quicksort belongs to a class of algorithm that employ a divide-and-conquer strategy. A divide-and-conquer strategy is typically based on subdividing the problem into smaller and smaller problems where each subdivision represents a partial solution. By subdividing, the size of the problem is reduced down to a point where the problem can no be subdivided again. Once this discrete solution level is reached, the complete solution is assembled from all the solutions to the subproblems. This class of algorithms can be solved iteratively, but due to the nature of the approach, can also be typically solved using a recursive implementation.

        // Get the current time (in milliseconds).
        long startTime = System.currentTimeMillis ();

        // Here's the code we're going to evaluate.
        selectionSort (A);

        // After it has run, we record the time taken as the current
        // time minus the starttime.
        long timeTaken = System.currentTimeMillis () - startTime;

        System.out.println ("Selection sort time: " + timeTaken);