Sorting, Searching and Performance

• The book discusses big-O notation In a callout box starting on page 274
• The book discusses searching and sorting in chapter 13, but that is mixed in with lists.
• We have discussed both in class.
• Sequential or Linear search.
  • The goal is to take a collection of data and a key and determine if the key is a member of the collection of data.
  • Either constant time, or sequential access will do in this case.
  • Algorithm

    • Search(array[], size, key)
          found = false
          index = 0;
          while not found and index < size 
              if array[index] = key
                 found = true
              index = index + 1
          return found
      

    • If we want, we can modify this to return a position we might consider

    • Search(array[], size, key)
          index = 0;
          poisiton = ITEM_NOT_FOUND
          while position == ITEM_NOT_FOUND and index < size 
              if array[index] == key
                 position = index
              index = index + 1
          return position
      

  • In either case, how many times will the main loop of this function run?
    • We would call this the performance.
    • If an array is 10 items long, the worst case is ten times through the loop.
    • If an array is n items long, the worst case is n times through the loop.
    • This is considered a $O(n)$
    • We could also consider comparison operations.
      • But we also do $O(n)$ comparisons.
    • In general $O(n)$ algorithms look at each piece of data once.
    • There is one other searching algorithm, binary search, but we will delay that for now.
  • Non Searching Algorithms

    • NonSearchA(ary[], size, key) 
         for each element e in ary
             if e == key
                return true
             else
                return false
              

    • NonSearchB(ary[], size, key) 
         found = false;
         for each element e in ary
             if e == key
                found = true
             else
                found =  false
         return found
              

  • Sorting
    • Selection Sort
      • The big idea was to continue to move the smallest remaining item to the front of the remaining list.

      • SelectionSort(array, size)
        
        for current = 0 to size-1 do
            minPos = current
            for j = current+1 to size do
               if array[minPos] > array[j]
                  minPos = j;
            if minPos != current
               Swap(array[minPos], array[current])
        

    • Insertion Sort
      • The big idea is to maintain a sorted list in the first portioin of the array, growing until the entire array is sorted.

      • InsertionSort(array, size)
        
        for last = 1 to size
          i = last;
          tmp = array[last];
          while i >= 1 and array[i-1] > tmp 
             array[i] = array[i-1]
             i--;
          array[i] = tmp
        

    • Performance
      • Both of these are $O(n^2)$
      • You count the number of times a comparison is made.
    • In general $O(n^2)$ algorithms compare each piece of data with every other piece of data.