Sorting and Searching

1
Sorting and Searching

• Pepper

2
Common Collection and Array Actions

• Sort in a certain order
• Max
• Min
• Shuffle
• Search
• Sequential (contains)
• Binary Search
• assumes sort, faster

3
Static Method Tools Classes

• Arrays
• binarySearch (array, value)
• sort(array)
• Collections
• binarySearch (list, value)
• shuffle(list)
• sort(list)
• max(list)
• min(list)

4
Sorting need order

• Comparable interface
• Only one order chosen as natural order
• Implemented inside order
• Implements ComparableltTgt
• int compareTo (SelfType o)
• int compareTo (Object o)
• Compare this item to the parm
• Used automatically by Collections sort
• Used automatically by TreeMap and TreeSet

5
Sorting Custom Order

• Comparator
• Custom order
• Independent of the object's definition
• Uses 2 objects and compares them
• int compare (Selftype s1, Selftype s2)
• No this
• just 2 input objects to compare
• Implements comparatorltTgt
• Outside the class being sorted
• Why
• Collections sort can use it
• TreeSet can use it
• TreeMap can use it

6
The Comparator Interface

• Syntax to implement
• public class lengthCom implements
  ComparatorltStringgt
• public int compare(String s1, String s2)
• Return s1.length() s2.length()
• Sorted list dog, cat, them, bunnies

7
How to use the Comparator

• Collections sort can take in a comparator
• Passed to methods as an extra parm
• Object passed into Collections.sort
• Ex Collections.sort(myarray, new
  myArraySorter())
• Use
• Arrays.sort(stringArray, new lengthCom())
• Collections.sort(stringList, new lengthCom())
• new TreeSetltStringgt (new lengthCom())

8
Stock Comparators

• String
• CASE_INSENSITIVE_ORDER
• Collections
• reverseOrder() returns comparator
• reverseOrder(comparator object)
• Returns opposite order of comparator
• Use
• Collections.sort(myStringList, CASE_INSENSITIVE_OR
  DER)
• Collections.sort(myStringList,
  Collections.reverseOrder(new lengthCom()))

9
Searching and Sorting

• Complexity measuring
• Search algorithms
• Sort algorithms

10
Complexity Measurements

• Empirical log start and end times to run
• Over different data sets
• Algorithm Analysis
• Assumed same time span (though not true)
• Variable declaration and assignment
• Evaluating mathematical and logical expressions
• Access or modify an array element
• Non-looping method call

11
How many units worst case

• Sample code find the largest value
• var M A 0 //lookup 1, assign 1
• for ( var i 0 i lt n i) // i o 1 test 1
• // retest 1
  i 1
• if ( A i gt M ) // test 1 lookup 1
• M A i // lookup 1, assign 1
• 4 2n 4n
• F(n) 4 2n 4n 4 6n
• Fastest growing term with no constant
• F(n) n (n is your array size)
• http//discrete.gr/complexity/

12
Practice with asymptote finding no constant

• f( n ) n2 3n 112 gives f( n ) n2
• f( n ) n sqrt(n) gives f( n ) n
• F(n) 2n 12 gives f(n) 2n
• F(n) 3n 2n gives f(n) 3n
• F(n) 3n 2n gives f(n) 3n
• Just test with large numbers

13
Practice with asymptote finding (dropping
constant)

• f( n ) 5n 12 gives f( n ) n.
• Single loop will be n
• called linear
• f( n ) 109 gives f( n ) 1.
• Need a constant 1 to show not 0
• Means no repetition
• Constant number of instructions

14
Determining f(n) for loops

• for (i 0 i lt n i)
• for (j 0 j lt n j)
• for (k 0 k lt n k)
• System.out.println(aijk)
• F(n) n3

15
Big O Notation Growth Rate

• F(n) n3 gives Big O Notation of O( n3 )
• Which will be slower than O(n)
• Which will be slower than O(1)

16
Searching

• Sequential
• Go through every item once to find the item
• Measure worst case
• 0(N)

17
Binary Search

• First Sorted
• Dictionary type search keep looking higher or
  lower
• Takes 0 seconds, but cannot be O(1) because it
  has a loop
• As input grows, number of times to divide min-max
  range grows as
• 2repetitions is approximately the Number of
  elements in the array
• So, repetitions log2N -? O(log2 N)

18
Binary Search code

• public static int findTargetBinary(int arr,
  int target)
• int min 0
• int max arr.length - 1
• while( min lt max)
• int mid (max min) / 2
• if (arrmid target)
• return mid
• else if (arrmid lt target)
• min mid 1
• else
• max mid - 1
• return -1

19
Selection Sort

• Find the smallest value's index
• Place the smallest value in the beginning via
  swap
• Repeat for the next smallest value
• Continue until there is no larger value
• Go through almost every item in the array for as
  many items as you have in the array
• Complexity O (N2)

20
Bubble Sort

• Initial algorithm
• Check every member of the array against the value
  after it if they are out of order swap them.
• As long as there is at least one pair of elements
  swapped and we havent gone through the array n
  times
• If the data is in order, it can be as efficient
  as O(n) or as bad as O(n2)

21
Merge Sort

• Two sorted subarrays can quickly be merged into a
  sorted array.
• Divide the array in half and sort the halves.
• Merge the halves.
• Picture http//www.java2novice.com/java-sorting-a
  lgorithms/merge-sort/
• Video http//math.hws.edu/TMCM/java/xSortLab/

22
Merge Sort Complexity

• Split array in half repeatedly until each
  subarray contains 1 element.
• 2repetitions is approximately the Number of
  elements in the array
• So, repetitions of division log2N
• O(log N)
• At each step, do a merge, go through each element
  once
• O(N)
• Together O (N log2 N)

23
Comparison speed

• Sequential Search - O(N)
• Binary Search - O(log2 N)
• Selection Sort - O(N2)
• Bubble Sort - O(N2)
• Merge Sort - O (N log2 N)
• https//www.ics.uci.edu/eppstein/161/960116.html

24
Summary

• Relative complexity O Notation
• Arrays and Collections class
• Different Search methods
• Sequential Search keep looking one by one
• Binary Search dictionary type split search
• Different Sort methods
• Selection Sort look through all to find
  smallest and put it at the beginning repeatedly
• Bubble Sort continual swapping pairs
  repeatedly
• Merge Sort - continually divide and sort then
  merge