Download Searching and Sorting Powerpoint

Comparing Objects in Java
• boolean result = obj1.equals(obj2);
• int diff = obj1.compareTo(obj2);
• int diff = c.compare(obj1, obj2);
14-1
obj1.equals(obj2) (cont’d)
• equals is called polymorphically from library
methods, such as ArrayList’s contains or
indexOf  that is why we have to properly
override Object’s equals.
• The equals method is properly defined in
String, Integer, Double, etc.
14-2
obj1.compareTo(obj2)
• compareTo is an abstract method defined
in the java.util.Comparable<T> interface:
public int compareTo (T other);
• Returns a positive integer if obj1 is
T is the type
parameter
“greater than” obj2, a negative integer if
obj1 is “less than” obj2, zero if they are
“equal.”
Sort of like obj1 - obj2
14-3
obj1.compareTo(obj2) (cont’d)
• compareTo is called polymorphically
from library methods, such as
Arrays.binarySearch(Object[ ] arr).
• Objects of classes that implement
Comparable are called “comparable”
(pronounced com-'parable).
• Strings, Integers, Doubles are
comparable.
14-4
obj1.compareTo(obj2) (cont’d)
«interface»
Comparable<String>
«interface»
Comparable<Integer>
«interface»
Comparable<Double>
String
Integer
Double
compareTo is
based on
lexicographical
order
compareTo is
based on
numerical values
14-5
Sequential Search
• Scans the list comparing the target value to
each element.
Dan
0
Fay
1
Cal
2
Ben
3
Guy
4
Amy
5
Amy?
Amy?
Amy?
Amy?
Amy?
Amy!
Eve
6
14-6
Sequential Search (cont’d)
public int sequentialSearch(Object [ ] arr, Object target)
{
for (int i = 0; i < arr.length ; i++)
{
if (target.equals(arr [i]))
return i;
}
return -1;
}
For primitive data types it is
if (value == arr [ i ])
14-7
Sequential Search (cont’d)
• The average number of comparisons
(assuming the target value is equal to one of
the elements of the array, randomly chosen)
is about n / 2 (where n = arr.length).
• Worst case: n comparisons.
• Also n comparisons are needed to establish
that the target value is not in the array.
• We say that this is an O(n) (order of n)
algorithm.
14-8
Binary Search
• The elements of the list must be arranged
in ascending (or descending) order.
• The target value is always compared with
the middle element of the remaining
search range.
• We must have random access to the
elements of the list (an array or ArrayList
are OK).
14-9
Binary Search (cont’d)
Amy
0
Ben
1
Cal
2
Dan
3
Eve
4
Fay
5
Guy
6
Eve
4
Fay
5
Guy
6
Eve?
Amy
0
Ben
1
Cal
2
Dan
3
Eve?
Amy
0
Ben
1
Cal
2
Dan
3
Eve
4
Fay
5
Guy
6
Eve!
14-10
Binary Search (cont’d)
• Recursive implementation:
public int binarySearch (int [ ] arr, int value, int left, int right)
{
if (right < left)
return -1;
// Not found
int middle = (left + right) / 2;
if (value == arr [middle] )
return middle;
else if (value < arr[middle])
return binarySearch (arr, value, left, middle - 1);
else // if ( value > arr[middle])
return binarySearch (arr, value, middle + 1, right);
}
14-11
Binary Search (cont’d)
• Iterative implementation:
public int binarySearch (int [ ] arr, int value, int left, int right)
{
while (left <= right)
{
int middle = (left + right) / 2;
if ( value == arr [middle] )
return middle;
else if ( value < arr[middle] )
right = middle - 1;
else // if ( value > arr[middle] )
left = middle + 1;
}
return -1; // Not found
}
14-12
Binary Search (cont’d)
• A “divide and conquer” algorithm.
• Works very fast: only 20 comparisons are
needed for an array of 1,000,000 elements;
(30 comparisons can handle 1,000,000,000
elements; etc.).
• We say that this is an O(log n) algorithm.
14-13
Sorting
• To sort means to rearrange the elements of a
list in ascending or descending order.
• Examples of sorting applications:





a directory of files sorted by name or date
bank checks sorted by account #
addresses in a mailing list sorted by zip code
hits found by a search engine sorted by relevance
credit card transactions sorted by date
14-14
Sorting (cont’d)
• The algorithms discussed here are based on
“honest” comparison of values stored in an
array. No tricks.
• How fast can we sort an array of n elements?


If we compare each element to each other we
need n(n-1) / 2 comparisons (that is, n2 by the
“order of magnitude.”)
Faster “divide and conquer” sorting algorithms
need approximately n·log2 n comparisons (much
better).
14-15
Sorting (cont’d)
Time
n2
n log2 n
n
n
n2
n log2 n
10
100
35
100
10,000
700
1000
1,000,000
10,000
14-16
Selection Sort
1. Select the max among the first n elements:
1 13
8
5
2
1
3
n
2. Swap it with the n-th element :
1
3
8
5
2
1 13
n
3. Decrement n by 1 and repeat from Step 1
(while n > 1)
1
3
8
5
n
2
1 13
14-17
Selection Sort (cont’d)
• Iterative implementation:
public void selectionSort (double [ ] arr, int n)
{
while (n > 1)
{
int maxPos = 0;
for (int k = 1; k < n; k++)
if (arr [k] > arr [maxPos] )
maxPos = k;
double temp = arr [maxPos];
swap a[maxPos]
arr [maxPos] = arr [n-1];
and a[n-1]
arr [n-1] = temp;
n--;
}
}
14-18
Selection Sort (cont’d)
• The total number of comparisons is
always
(n-1) + (n-2) + ... + 1 = n(n-1) / 2
• No average, best, or worst case —
always the same.
• An O(n2) algorithm.
14-19
Insertion Sort
1. k = 1; keep the first k elements in order.
2. Take the (k+1)-th element and insert among the
first k in the right place.
2
13 1 8
1 3 5
k
3. Increment k by 1; repeat from Step 2 (while k < n)
1
2
3
5 13 1
8
k
14-20
Insertion Sort (cont’d)
• Iterative implementation:
public void insertionSort (double [ ] arr, int n)
{
for (int k = 1 ; k < n; k++)
{
double temp = arr [ k ];
int i = k;
while (i > 0 && arr [i-1] > temp)
{
arr [i] = arr [i - 1];
i --;
}
arr [i] = temp;
}
}
shift to the
right
14-21
Insertion Sort (cont’d)
• The average number of comparisons is
roughly half of the number in Selection Sort.
• The best case is when the array is already
sorted: takes only (n-1) comparisons.
• The worst case is n(n-1) / 2 when the array is
sorted in reverse order.
• On average, an O(n2) algorithm.
14-22
Mergesort
1. Split the array into two roughly equal “halves.”
5
1
3
2
4
7
6
2. Sort (recursively) each half using... Mergesort.
1
3
5
2
4
6
7
3. Merge the two sorted halves together.
1 3
1 2 3
2 4
5
6
7
The smaller value goes first
14-23
Mergesort (cont’d)
public void mergesort (double[ ] arr,
int from, int to)
{
if (from <= to)
return;
int middle = (from + to ) / 2;
mergesort (arr, from, middle);
mergesort (arr, middle + 1, to);
if (arr [middle] > arr [middle + 1])
{
copy (arr, from, to, temp) ;
merge (temp, from, middle, to, arr);
}
}
Base case
Optional shortcut:
“if not yet sorted”...
double[ ] temp is
initialized outside
the mergesort
method
14-24
Mergesort (cont’d)
• Takes roughly n·log2 n comparisons.
• Without the shortcut, there is no best or worst
case.
• With the optional shortcut, the best case is
when the array is already sorted: takes only
(n-1) comparisons.
• An O(n log n) algorithm.
14-25
Quicksort
1. Pick one element, called “pivot”
5
1
6
2
4
7
3
2. Partition the array, so that all the elements to the
left of pivot are  pivot; all the elements to the
right of pivot are  pivot.
4
1
3
2
5
7
6
3. Sort recursively the left and the right segments
using... Quicksort.
14-26
Quicksort (cont’d)
• Takes roughly n·log2 n comparisons.
• May get slow if pivot consistently fails to split
the array into approximately equal halves.
• An O(n log n) algorithm.
14-27
The Benchmarks program
Enter the array
size
Choose the
sorting algorithm
Running time in
milliseconds
14-28
java.util.Random
• Benchmarks uses the java.util.Random
class — a more controlled way to generate
random numbers.
• Constructors:
the seed is different
each time
Random generator1 = new Random( );
Random generator2 = new Random(seed);
long seed;
• If we set the same seed, we get the same
“random” sequence.
14-29
java.util.Random (cont’d)
• Methods:
int k = generator.nextInt (n);
0k<n
double x =
generator.nextDouble ( );
0x<1
14-30
java.util.Arrays
• Provides static methods for dealing with
arrays.
• Works for arrays of numbers, Strings, and
Objects.
• Methods:
int pos = Arrays.binarySearch (arr, target);
Arrays.sort (arr);
Arrays.fill (arr, value); // fills arr with a given value
String str = Arrays.toString(arr);
Arrays.asList(arr);
Returns a representation of
arr as a fixed-length list
14-31
java.util.Collections
• Provides static methods for dealing with
ArrayLists and other Java collections.
• Works for arrays of numbers, Strings, and
Objects.
• Methods:
int pos = Collections.binarySearch (list, target);
Collections.sort (list);
Collections.shuffle (list);
14-32
Review:
• What is the type of the parameter in the
equals method?
• How many methods are listed in the
Comparable interface?
• What is a comparator?
• How many comparisons are needed in the
worst case to find the target value among 15
values using Sequential Search? Using
Binary Search?
14-33
Review (cont’d):
• Describe briefly the main idea of Selection
Sort.
• Describe briefly the main idea of Insertion
Sort.
• Is it easier to implement Mergesort
recursively or iteratively?
• What is the average number of comparisons
in Mergesort?
• Name a few methods of the java.util.Arrays
class.
14-34