Algorithms and OOD (CSC 207 2014S) : EBoards

CSC207.01 2014S, Class 25: An Introduction to Sorting


Overview

Preliminaries

Upcoming Work

Admin

Questions on HW5

The problem of sorting

Let's write a signature

public AN ARRAY sort(AN ARRAY, THE THING THAT DOES THE COMPARISONS)

Design issues:

Let's make that look more like Java

public int[] sort(int[] vals, Comparator<Integer> order)

Using this model

sort(grades, new Comparator<Integer>()
                   {
                     public int compare(Integer x, Integer y)
                     {
                       return x-y;  // Hack.  Dangerous
                     }
                   } // Comparator<Integer>
                   );

Whoops. Might overflow.

Let's generalize

public static <T> T[] sort(T[] vals, Comparator<T> order)

An object-oriented approach

Perhaps sort should be a mutator of the array class.

public class JavaArray
{
  public void sort(Comparator<T> order)
} // class JavaArray

Object-oriented strategy: Make objects that know how to sort

public interface Sorter { /* *Sort an array without mutation, return the sorted version. * * @pre * No elements may be null. */ public T[] pureSort(T[] vals, Comparator order); /* * Sort an array in place. */ public sortInPlace(T[] vals, Comparator order); } // class

Do we also have sorting routines for things with a natural order, such as BigIntegers or Strings.

 public T[] pureSort(Comparable<T>[] vals) // Approximate syntax

Another design decision: Is the sorting algorithm "stable"?

Four algorithms to study

Testing our sorting algorithm

Unit tests for sorting algorithms

Copyright (c) 2013-14 Samuel A. Rebelsky.

Creative Commons License

This work is licensed under a Creative Commons Attribution 3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/by/3.0/ or send a letter to Creative Commons, 543 Howard Street, 5th Floor, San Francisco, California, 94105, USA.