Module 3: Sorting

import java.util.*;

public class InsertionSort1 {

    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));
        
	int[] sortedData = insertionSort (testData);

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

    static int[] insertionSort (int[] A)
    {
        // Make space for the "result" array B:
        int[] B = new int [A.length];

        // Go through A's elements and find the right place for each in B:
	for (int i=0; i < A.length; i++) {

            // Find the right place for A[i] in array B.
            int posInB = i;
            for (int j=0; j < i; j++) {
                if (B[j] < A[i]) {
                    // Skip.
                }
                else {
                    posInB = j;
                    break;
                }
            }

            // Now shift rightwards in B from posInB onwards.
            for (int j=i+1; j>posInB; j--) {
                // We need this because the array has to be shifted except
                // for the last position when i=n-1.
                if (j < B.length) {
                    B[j] = B[j-1];
                }
            }
            
            // Assign A[i] in right place.
            B[posInB] = A[i];
	}

        return B;
    }
    
    static int[] makeRandomArray (int length)
    {
        // ...
    }

}

    static int[] insertionSort (int[] A)
    {
        int[] B = new int [A.length];

	for (int i=0; i < A.length; i++) {

            B[i] = A[i];
            
            // Start at rightmost element in B.
            int j = i;

            // Swap as we go backwards.
            while ( (j > 0) && (B[j] < B[j-1]) ) {
                int temp = B[j];
                B[j] = B[j-1];
                B[j-1] = temp;
                j --;            // Mustn't forget the decrement.
            }
            
	}

        return B;
    }

    static void insertionSort (int[] A)
    {
	for (int i=0; i < A.length; i++) {

            // Find the right place for A[i].
            int j = i;

            while ( (j > 0) && (A[j] < A[j-1]) ) {
                // Swap until we stop.
                int temp = A[j];
                A[j] = A[j-1];
                A[j-1] = temp;
                j --;
            }
            
	}
    }

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

• In the int version of Selection-Sort, the key comparison occured in the for-loop:

  	    for (int j=i+1; j < A.length; j++) {
  		if (A[j] < smallest) {
  		    smallest = A[j];
  		    pos = j;
  		}
  	    }
      

  Here, A[i] (an int) is compared to smallest (also an int).

• In the Person example,

  	    for (int j=i+1; j < people.length; j++) {
  		if ( people[j].lessThan (min) ) {
  		    min = people[j];
  		    pos = j;
  		}
  	    }
      

  Here, people[j] (a Person instance) is compared to min (also a Person instance).

• The comparison itself is done inside the method lessThan() in one instance.

Quicksort

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;
    }

}

        // 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);