Searching and Sorting

A quick look at some algorithms on arrays
- Searching is the process of finding an item in an array or list.
- Sorting is the process of placing an array or list in order.
- These are examples of classical algorithms.
- There are a limited number of searching algorithms.
- There are many many sorting algorithms.
Linear or Sequential search
- Generally takes and array and the number of items in the array
- And a key
- And returns the position of the key in the array
- Or a flag indicting that the item is not present.
- The algorithm
```
Find(array, size, key) 
   for each item in the array
      if the item is equal to the key
         return position
   return SEARCH_NOT_FOUND
```
- Implementation
  - Define the function prototype and SEARCH_NOT_FOUND in the header file.
- Test plan
  - Search for items not in the array
  - Search for items in the array
    - The first item.
    - The last item.
    - Items in the middle
  - Search a array with no items.
  - Search an array with maximum items.
- Performance is O(1) in the best case, O(n) in the average and worst cases.

Sorting

We will look at two algorithms now

Insertion Sort

Big idea
- An array of one item is sorted
- To add an item to a sorted array, put it at the end and move it forward to the correct position.

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

Selection Sort

Big idea: make multiple passes through the array
Each time select the smallest item and move it to the front of the array.

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])