1. Sorting
Chapter 8
CS 225

2. Chapter Objectives
To learn how to use the standard sorting methods in the Java API
To learn how to implement the following sorting algorithms: selection sort, bubble sort, insertion sort, Shell sort, merge sort, heapsort, and quicksort
To understand the difference in performance of these algorithms, and which to use for small arrays, which to use for medium arrays, and which to use for large arrays
CS 225

3. Declaring a Generic Method
We have seen generic classes throughout the semester.
You can also declare generic methods.
methodModifiers <generic parameters>
returnType methodName(
methodParameters)
List the generic type(s) between the modifiers and the return type; use them in the parameter list, return type(?) and body of method as needed.
public static <T extends Comparable<T>> int binarySearch( T[] items, T target)
CS 225

4. Using Java Sorting Methods
Java API provides a class Arrays with several overloaded sort methods for different array types
The Collections class provides similar sorting methods for Lists
Sorting methods for arrays of primitive types are based on quicksort algorithm
Method of sorting for arrays of objects and Lists based on mergesort
CS 225

5. java.util.Arrays Two versions of sort for each primitive type
public void sort( int [] values)
public void sort( int [] values, int from, int to)
Four sort methods for objects
public static void sort( Object [] items)
public static void sort( Object [] items,
int from, int to)
public static <T> void sort(
<T> [] items, Comparator<? super T> comp)
<T> [] items, Comparator<? super T> comp,
Object types must implement the Comparable interface
CS 225

6. java.util.Collections
Two methods for sorting collections that implement the List interface
public static
<T extends Comparable<T>>
void sort( List<T>list)
public static <T> void sort(
List<T> list,
Comparator<? super T> comp)
CS 225

7. Selection Sort
Selection sort is a relatively easy to understand algorithm
Sorts an array by making several passes through the array, selecting the next smallest item in the array each time and placing it where it belongs in the array
Efficiency is O(n*n)
CS 225

8. Selection Sort Algorithm
for fill = 0 to n-2 do
posMin = fill
for next = fill + 1 to n-1
if item at next < item at posMin
posMin = next
swap elements at fill and posMin
CS 225

9. Selection Sort Algorithm
Basic rule: on each pass select the smallest remaining item and place it in its proper location
CS 225

10. Selection Sort Efficiency
Selection sort is called a quadratic sort
Number of comparisons is O(n*n)
Number of exchanges is O(n)
In best case (already sorted)
Number of comparisons is still O(n*n)
Number of exchanges is O(1)
CS 225

11. Bubble Sort
Compares adjacent array elements and exchanges their values if they are out of order
Smaller values bubble up to the top of the array and larger values sink to the bottom
CS 225

12. Analysis of Bubble Sort
Provides excellent performance in some cases and very poor performances in other cases
Works best when array is nearly sorted to begin with
Worst case number of comparisons is O(n*n)
Worst case number of exchanges is O(n*n)
Best case occurs when the array is already sorted
O(n) comparisons
O(1) exchanges
CS 225

13. Insertion Sort
Based on the technique used by card players to arrange a hand of cards
Player keeps the cards that have been picked up so far in sorted order
When the player picks up a new card, he makes room for the new card and then inserts it in its proper place
CS 225

14. Insertion Sort Algorithm
For each array element from the second to the last (nextPos = 1)
Insert the element at nextPos where it belongs in the array, increasing the length of the sorted subarray by 1
CS 225

15. Analysis of Insertion Sort
Maximum number of comparisons is O(n*n)
In the best case (already sorted), number of comparisons is O(n)
The number of shifts performed during an insertion is one less than the number of comparisons or, when the new value is the smallest so far, the same as the number of comparisons
A shift in an insertion sort requires the movement of only one item whereas in a bubble or selection sort an exchange involves a temporary item and requires the movement of three items
CS 225

16. Comparison of Quadratic Sorts
None of the algorithms are particularly good for large arrays
Comparisons
Exchanges
Sort
Best
Worst
Selection
O(n2)
O(n)
Bubble
O(1)
Insertion
CS 225

17. Shell Sort
Shell sort is a type of insertion sort but with O(n(3/2)) or better performance
Named after its discoverer, Donald Shell
Divide and conquer approach to insertion sort
Instead of sorting the entire array, sort many smaller subarrays using insertion sort before sorting the entire array
CS 225

18. Shell Sort CS 225 Start with gap of n/2
Divide by 2.2 and round down for successive gaps
CS 225

19. Analysis of Shell Sort
A general analysis of Shell sort is an open research problem in computer science
Performance depends on how the decreasing sequence of values for gap is chosen
If successive powers of two are used for gap, performance is O(n*n)
If Hibbard’s sequence is used, performance is O(n3/2)
CS 225

20. Merge Sort
A merge is a common data processing operation that is performed on two sequences of data with the following characteristics
Both sequences contain items with a common compareTo method
The objects in both sequences are ordered in accordance with this compareTo method
CS 225

21. Merge Algorithm Merge Algorithm
Access the first item from both sequences
While not finished with either sequence
Compare the current items from the two sequences, copy the smaller current item to the output sequence, and access the next item from the input sequence whose item was copied
Copy any remaining items from the first sequence to the output sequence
Copy any remaining items from the second sequence to the output sequence
CS 225

22. Merge Example
CS 225

23. Analysis of Merge
For two input sequences that contain a total of n elements, we need to move each element’s input sequence to its output sequence
Merge time is O(n)
We need to be able to store both initial sequences and the output sequence
The array cannot be merged in place
Additional space usage is O(n)
CS 225

24. Algorithm for Merge Sort
if tablesize >1
halfsize = tablesize / 2
copy left half to separate leftTable
recursively sort leftTable
copy right half to separate rightTable
recursively sort rightTable
merge leftTable and rightTable
CS 225

25. Trace of Merge Sort
CS 225

26. Heapsort
Merge sort time is O(n log n) but still requires, temporarily, n extra storage items
Heapsort does not require any additional storage
build a max-heap from the array
swap first element with last to put largest element at end
build a heap from the unsorted part of the array
CS 225

27. Heapsort
CS 225

28. Heapsort
CS 225

29. Quicksort Developed in 1962
Quicksort rearranges an array into two parts so that all the elements in the left subarray are less than or equal to a specified value, called the pivot
Quicksort ensures that the elements in the right subarray are larger than the pivot
Average case for Quicksort is O(n log n)
CS 225

30. Quicksort
CS 225

31. Algorithm for Partitioning
pivot = table[first]
up = first
down = last
while table[up]<=pivot and up<down
increment up
while table[down]>pivot and down>up
decrement down
swap table[down] and table[first]
pivotIndex = down
CS 225

32. Partitioning
CS 225

33. Revised Partition Algorithm
Quicksort is O(n*n) when each split yields one empty subarray, which is the case when the array is presorted
Best solution is to pick the pivot value in a way that is less likely to lead to a bad split
Requires three markers
First, middle, last
Select the median of the these items as the pivot
CS 225

34. Testing the Sort Algorithms
Need to use a variety of test cases
Small and large arrays
Arrays in random order
Arrays that are already sorted
Arrays with duplicate values
Compare performance on each type of array
CS 225

35. Comparing Sorts Sort Best Average Worst Selection O(n2) Bubble O(n)
Insertion
Shell
O(n7/6)
O(n5/4)
Merge
O(n log n)
Heap
Quick
CS 225

36. The Dutch National Flag Problem
A variety of partitioning algorithms for quicksort have been published
A partitioning algorithm for partitioning an array into three segments was introduced by Edsger W. Dijkstra
Problem is to partition a disordered three-color flag into the appropriate three segments
CS 225

37. The Dutch National Flag Problem
CS 225

38. Algorithm for 0<=i<red, color is red
for red<=i<=white, color is unknown
for white<i<=blue, color is white
for blue<i<=height, color is blue
red = 0
blue = white = height-1
while red<white
if threads[white] is
white: white--
red:
swap elements at
red and white
red++
blue:
blue and white
blue--
white--
CS 225

39. Chapter Review Comparison of several sorting algorithms were made
Three quadratic sorting algorithms are selection sort, bubble sort, and insertion sort
Shell sort gives satisfactory performance for arrays up to 5000 elements
Quicksort has an average-case performance of O(n log n), but if the pivot is picked poorly, the worst case performance is O(n*n)
Merge sort and heapsort have O(n log n) performance
CS 225

40. Chapter Review
The Java API contains “industrial strength” sort algorithms in the classes java.util.Arrays and java.util.Collections
CS 225