spring 2010cs 2251 sorting chapter 8. spring 2010cs 2252 chapter objectives to learn how to use the...
Post on 20-Dec-2015
215 views
TRANSCRIPT
Spring 2010 CS 225 1
Sorting
Chapter 8
Spring 2010 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
Spring 2010 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)
Spring 2010 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
Spring 2010 CS 225 5
java.util.Arrays
• Two versions of sort for each primitive typepublic void sort( int [] values)public void sort( int [] values, int from, int to)
• Four sort methods for objectspublic 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)public static <T> void sort( <T> [] items, Comparator<? super T> comp, int from, int to)
Spring 2010 CS 225 6
java.util.Collections
• Two methods for sorting collections that implement the List interfacepublic static
<T extends Comparable<T>>
void sort( List<T>list)
public static <T> void sort(
List<T> list,
Comparator<? super T> comp)
Spring 2010 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)
Spring 2010 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
Spring 2010 CS 225 9
Selection Sort Algorithm
• Basic rule: on each pass select the smallest remaining item and place it in its proper location
Spring 2010 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)
Spring 2010 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
Spring 2010 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
Spring 2010 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
Spring 2010 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
Spring 2010 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
Spring 2010 CS 225 16
Comparison of Quadratic Sorts
• None of the algorithms are particularly good for large arrays
Comparisons Exchanges
Sort Best Worst Best Worst
Selection O(n2) O(n2) O(n) O(n)
Bubble O(n) O(n2) O(1) O(n2)
Insertion O(n) O(n2) O(n) O(n2)
Spring 2010 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
Spring 2010 CS 225 18
Shell Sort
Spring 2010 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)
Spring 2010 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
Spring 2010 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
Spring 2010 CS 225 22
Merge Example
Spring 2010 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)
Spring 2010 CS 225 24
Algorithm and Trace of 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
Spring 2010 CS 225 25
Trace of Merge Sort
Spring 2010 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
Spring 2010 CS 225 27
Heapsort
Spring 2010 CS 225 28
Heapsort
Spring 2010 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)
Spring 2010 CS 225 30
Quicksort
Spring 2010 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
Spring 2010 CS 225 32
Algorithm for Partitioning
Spring 2010 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
Spring 2010 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
Spring 2010 CS 225 35
Comparing Sorts
Sort Best Average Worst
Selection O(n2) O(n2) O(n2)
Bubble O(n) O(n2) O(n2)
Insertion O(n) O(n2) O(n2)
Shell O(n7/6) O(n5/4) O(n2)
Merge O(n log n) O(n log n) O(n log n)
Heap O(n log n) O(n log n) O(n log n)
Quick O(n log n) O(n log n) O(n2)
Spring 2010 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
Spring 2010 CS 225 37
The Dutch National Flag Problem
Spring 2010 CS 225 38
Algorithm• for 0<=i<red, color is
red• for red<=i<=white, color
is unknown• for white<i<=blue, color
is blue• 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:• swap elements at • blue and white• blue--• white--
Spring 2010 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
Spring 2010 CS 225 40
Chapter Review
• The Java API contains “industrial strength” sort algorithms in the classes java.util.Arrays and java.util.Collections