Searching

• Linear search: also called sequential search
• Examines all values in an array until it finds a match or reaches the end
• Number of visits for a linear search of an array of n elements:
  • The average search visits n/2 elements
  • The maximum visits is n
• A linear search locates a value in an array in O(n) steps

section_6_1/LinearSearcher.java

section_6_1/LinearSearchDemo.java

Program Run:

• [46, 99, 45, 57, 64, 95, 81, 69, 11, 97, 6, 85, 61, 88, 29, 65, 83, 88, 45, 88]
  Enter number to search for, -1 to quit: 12
  Found in position -1
  Enter number to search for, -1 to quit: -1

Binary Search

• A binary search locates a value in a sorted array by:
  • Determining whether the value occurs in the first or second half
  • Then repeating the search in one of the halves
• The size of the search is cut in half with each step.

Binary Search

• Searching for 15 in this array
  
  
• The last value in the first half is 9
  • So look in the second (darker colored) half
    
• The last value of the first half of this sequence is 17
  • Look in the darker colored sequence
    
• The last value of the first half of this very short sequence is 12,
  • This is smaller than the value that we are searching,
  • so we must look in the second half
    
• 15 ≠ 17: we don't have a match

section_6_2/BinarySearcher.java

Binary Search

• Count the number of visits to search a sorted array of size n
  • We visit one element (the middle element) then search either the left or right subarray
  • Thus: T(n) = T(n/2) + 1
• If n is n / 2, then T(n / 2) = T(n / 4) + 1
• Substituting into the original equation: T(n) = T(n / 4) + 2
• This generalizes to: T(n) = T(n / 2^k) + k

Binary Search

• Assume n is a power of 2, n = 2^m
  where m = log₂(n)
• Then: T(n) = 1 + log₂(n)
• A binary search locates a value in a sorted array in O(log(n)) steps.

Binary Search

• Should we sort an array before searching?
  • Linear search - O(n)
  • Binary search - O(n log(n))
• If you search the array only once
  • Linear search is more efficient
• If you will make many searches
  • Worthwhile to sort and use binary search

Lecture 12 Clicker Question 2

Suppose you need to look through a sorted array with 1,000,000 address records that are already sorted by telephone number. Using the binary search algorithm, how many records do you expect to search before finding a given number, or conclude that it is not present?

1. About 20
2. About 500,000
3. 1,000,000
4. 1,000,000 squared

Problem Solving: Estimating the Running Time of an Algorithm - Linear time

• Example: an algorithm that counts how many elements have a particular value

  int count = 0;
  for (int i = 0; i < a.length; i++)
  {
     if (a[i] == value) { count++; }
  }

• Pattern of array element visits
  
• There are a fixed number of actions in each visit independent of n.
• A loop withn iterations has O(n) running time if each step consists of a fixed number of actions.

Problem Solving: Estimating the Running Time of an Algorithm - Linear time

• Example: an algorithm to determine if a value occurs in the array

  boolean found = false;
  for (int i = 0; !found && i < a.length; i++)
  {
     if (a[i] == value) { found = true; }
  }

• Search may stop in the middle
  
• Still O(n) because we may have to traverse the whole array.

Problem Solving: Estimating the Running Time of an Algorithm - Quadratic time

• Problem: Find the most frequent element in an array.
• Try it with this array
  
• Count how often each element occurs.
  • Put the counts in an array
    
  • Find the maximum count
  • It is 3 and the corresponding value in original array is 7

Problem Solving: Estimating the Running Time of an Algorithm - Quadratic time

• Estimate how long it takes to compute the counts

  for (int i = 0; i < a.length; i++)
  {
      counts[i] = Count how often a[i] occurs in a
  }

  • We visit each array element once - O(n)
  • Count the number of times that element occurs - O(n)
  • Total running time - O(n²)
• Three phases in the algorithm
  • Compute all counts. O(n²)
  • Compute the maximum. O(n)
  • Find the maximum in the counts. O(n)
• A loop with n iterations has O(n²) running time if each step takes O(n) time.
• The big-Oh running time for doing several steps in a row is the largest of the big-Oh times for each step.

The Triangle Pattern

• Try to speed up the algorithm for finding the most frequent element.
• Idea - Before counting an element, check that it didn't already occur in the array
  • At each step, the work is O(i)
  • In the third iteration, visit a[0] and a[1] again
    
• n²/2 lightbulbs are visited (light up)
• That is still O(n²)
• A loop with n iterations has O(n²) running time if the i^th step takes O( i ) time.

Problem Solving: Estimating the Running Time of an Algorithm - Logarithmic time

• Logarithmic time estimates arise from algorithms that cut work in half in each step.
• Another ideas for finding the most frequent element in an array:
  • Sort the array first
    
  • This is O(n log(n)) time
• Traverse the array and count how many times you have seen that element:
  
• The code

  int count = 0;
  for (int i = 0; i < a.length; i++)
  {
     count++;
     if (i == a.length - 1 || a[i] != a[i + 1])
     {
        counts[i] = count;
        count = 0;
     }
  }
  

Problem Solving: Estimating the Running Time of an Algorithm - Logarithmic time

• This takes the same amount of work per iteration:
  • visits two elements
  • 2n which is O(n)
    
• Running time of entire algorithm is O(n log(n)).
• An algorithm that cuts the size of work in half in each step runs in O(log(n)) time.

Lecture 12 Clicker Question 3

What is the big-Oh running time of the following algorithm to check whether the first element is duplicated in an array?

for (int i = 1; i < a.length; i++)
{
   if (a[0] == a[i]) { return true; }
}
return false;

1. O(log n)
2. O(n)
3. O(n log n)
4. O(n²)

Lecture 12 Clicker Question 4

What is the big-Oh running time of the following algorithm to check whether an array has a duplicate value?

for (int i = 0; i < a.length; i++)
{
   for (j = i + 1; j < a.length; j++)
   {
      if (a[i] == a[j]) { return true; }
   }
}
return false;

1. O(log n)
2. O(n)
3. O(n log n)
4. O(n²)

Sorting and Searching in the Java Library - Sorting

• Shocking revelation (to CS instructors): Nobody pays you to sort integers
• In real life, you sort file names, search results, birth records, etc.
• Shocking revelation #2: Someone already wrote perfectly good sorting functions
• Arrays.sort
• Arrays.binarySearch
• Collections.sort
• Works with  Comparable objects, or supply Comparator

Sorting and Searching in the Java Library - Binary Search

• Arrays and Collections classes contain static binarySearch methods.
  • If the element is not found, returns -k - 1
  • Where k is the position before which the element should be inserted
• For example

  int[] a = { 1, 4, 9 };
  int v = 7;
  int pos = Arrays.binarySearch(a, v);
  // Returns –3; v should be inserted before position 2

Comparing Objects

• Arrays.sort sorts objects of classes that implement Comparable interface:

  public interface Comparable
  {
     int compareTo(Object otherObject);
  }

• The call a.compareTo(b) returns
  • A negative number if a should come before b
  • 0 if a and b are the same
  • A positive number otherwise

Comparing Objects

• Several classes in Java (e.g. String and Date) implement Comparable.
• You can implement Comparable interface for your own classes.
• The Country class could implement Comparable:

  public class Country implements Comparable
  {
     public int compareTo(Object otherObject)
     {
        Country other = (Country) otherObject;
        if (area < other.area) { return -1; }
        else if (area == other.area) { return 0; }
        else { return 1; }
     }
  } 

• You could pass an array of countries to Arrays.sort

  Country[] countries = new Country[n];
  // Add countries
  Arrays.sort(countries); // Sorts by increasing area

Lecture 12 Clicker Question 5

You are given an ArrayList<Rectangle> and want to sort it by increasing area. What do you do?

1. Call Arrays.sort and take advantage of the fact that Rectangle implements Comparable
2. Call Arrays.sort and provide a suitable Comparator object
3. Call Collections.sort and take advantage of the fact that Rectangle implements Comparable
4. Call Collections.sort and provide a suitable Comparator object