Searching Problem

• Input:
  1. Set S of keys of some type T
  2. Value t of type T
• Output: Location of element s in S such that t == s
• General assumptions:
1. Assume that (!(s1 < s2) and !(s2 < s1)) implies (s1 == s2)
2. Satellite data associated with keys may be considerable
3. Definition of order and equality operators may be independent of satellite data
4. May use indirection to avoid copying of satellite data
5. Set S may have additional structure that assists in search

Sequential Search

• Assumption: The set is traversable, i.e.:
1. Set S has Begin() and End()
2. Begin() determines an element
3. If s is an element then Next(s) determines another element or End()
4. The loop

   for ( s = S.Begin() ; s != S.End() ; s = S.Next(s) )
   {}
   

   traverses the entire set S
• Body

Locator sequential_search (traversable set S of elements of type T, T t)
{
  for ( s = S.Begin() ; s != S.End() ; s = S.Next(s) )
  {
    if (t == s)
      return s;
  }
  return S.End();
}

• Proof of Halting (done)
• Proof of Correctness (done)
• Runtime Analysis (done), Result: Worst case = Average Case = Θ(n)
• Runspace Analysis (done), Result: in-place

Binary Search - 1

• Assumptions
1. Set has sequential structure
2. Set has "random access" iterator, equivalently:
   Set has bracket operator
3. Set is sorted
• Body - Recursive

size_t r_binary_search (T* A, size_t L, size_t H, T t)
// pre:  A[L,H) is sorted - note H is past the end of the search
// post: no change in A
// return: index of first occurrence of t in A, or
//         index where t should be inserted to retain sorted order
{
  size_t M;
  if (L < H) // search range is not empty
    {
      M = (L + H)/2;
      if (A[M] < t) // t is not in [L..M]
        return r_binary_search (A, M+1, H, t);
      else          // t is not in [M..H)
        return r_binary_search (A, L, M, t);
    }
  else
    return H;
}

• Body - Iterative

size_t i_binary_search (T* A, size_t L, size_t H, T t)
// pre:  A[L,H) is sorted - note H is past the end of the search
// post: no change in A
// return: index of first occurrence of t in A, or
//         index where t should be inserted to retain sorted order
{
  size_t M;
  while (L < H)
    {
      M = (L + H)/2;
      if (A[M] < t)  // t is not in [L..M]
        L = M + 1;
      else           // t is not in [M..H)
        H = M;
    }
  return H;
}

• Proof of Halting
• Proof of Correctness
• Runtime Analysis, Result: Worst case = Average Case = Θ(log n)
• Runspace Analysis, Result: in-place