Searching and Sorting

• Two classic operations on arrays are searching and sorting.
• Searching involves determining if an element is in the array
• Sorting involves placing the array in some order.
• For both of these operations we consider some key field.
  • For a simple data type, this is the data type.
  • For more complex data types, this is a field or a set of fields.
  • For example: In your student record, I bet they use your banner id for the key.
  • In the campus directory they use your name, Last, First, Middle.
• Both of these operations require comparison operators.
  • == is required for a search.
  • < or > for a sort.
• One other assumption, if the key fields are the same, the items match.

Linear Search

• This is also called sequential search.
• This material is from page 673-676, Sequential Search.
• If we have a collection of items we may want to determine if a given item is in that collection.
• This is probably an array, but soon we will have another data structure to work with.
• We assume no knowledge of the arrangement of the data.
• For the algorithm, we will return true if the item is in the array and false if it is not.
  • In other instances we may want to know the location
  • Or even the data record.

• bool LinearSearch(dataType array[], dataType key,  int size) {
       int i;
       bool found;
      
       i = 0;
       found = false;
  
       while(!found && i < size) {
           if (array[i] == key) {
  	     found = true;
  	 } else {
  	     i++;
  	 }
       }
       return found;
  }
      

  • What happens when an item is in the array?
  • What happens when an item is not in an array?
  • Consider the special cases, key is first item or key is last item.
  • Notice, this returns the first instance of the item found in the list, what if we wanted the last instance of the item?
• Can we describe how this algorithm will perform?
  • When will it take a long time?
  • When will it finish quickly?
  • On average what will the performance be?
  • On page 274-279 you (possibly) discussed algorithm analysis.
  • In this case, we talk about best, worst, and average case performance.
  • We talk about this in terms of the size of the input data.
  • The Best case occurs when the key is the first item in the list.
    • In this case, the size of the input data does not matter.
    • The while loop only executes once.
    • The performance is O(1)
  • The Worst case is when the key is not in the data.
    • In this case, we look at every single data item once.
    • This is an O(n) algorithm, where n is the number of items in the array (size)
  • The Average case:
    • Assume that the item is in the array.
    • Then compute how long it will take to find in.
    • Assume that it is equally likely that the key will be in any position.
    • We can find the expected value of operations.
      • p_i is the probability that the item is at position i.
      • c_i is the cost to locate the item at position i.
      • So the sum is : E = p₀c₀+ p₁c₁+ p₂c₂+ ... + p_n-2c_n-2+ p_n-1c_n-1
      • With equal probability, p_i = p_j
      • so the equation becomes : E = p₀c₀+ p₀c₁+ p₀c₂+ ... + p₀c_n-2+ p₀c_n-1
      • Which is really : E = p₀(c₀+c₁+c₂+ ... + c_n-2+ c_n-1)
      • Next, we can observe that c_i = i+1
      • So the computation becomes: p_i (1 + 2 + ... + n)
      • We know Σ ⁿ _i=1 i = 1 + 2 + ... + n = n(n+1)/2
      • So the computation becomes p_i(n)(n+1)/2
      • But p_i = 1/n
      • And we have E = (n+1)/2
      • Which is O(n)
    • By throwing in missing keys, this just gets closer to n.