• Examines entries of an array in order until a match is found or all of the entries have been examined.
• It is inefficient for large arrays:
  • Let n be the number of elements in the array.
  • It takes on the average, n/2 comparisons to search an array if the value is in the array.
  • It takes n comparisons to search an array to determine that the value is not there.
• The linear search algorithm is said to be order n (This is know as Big O of n and is written O(n).)

• Relies on the array values being sorted either in ascending or descending order.
• Uses a divide and conquer strategy.
• Suppose the array is sorted in ascending order (smallest to biggest).
• Compare the value at the half way point in the array to the value you are looking for.
• If the array value is too small, you know that the search value has to be in the last half of the array.
• Similarly if the array value is too big, you know that the search value has to be in the first half of the array.
• In either case you reduced the problem to searching an array that is half of the size of the original one.
• How many times do you have to repeat the dividing process?
  • Let n be the number of elements in the array.
  • Let k be the number of times you halve the array.
  • You can get an estimate by observing that n (1/2)k must be greater than or equal to 1.
  • Solving, k = ln2 (n)
• Binary search is O(ln n).

public int binarySearch(int [] x, int value) {
   int low = 0;
   int high = x.length - 1;
   while (low <= high) {
      int mid = (low + high)/2;
      if (x[mid] == value)
         return mid;
      else if (x[mid] < value)
         low = mid + 1;
      else    
         high = mid - 1;
   }
   return -1;
}

• Suppose you have an array of size n.
• Look for the smallest value in the last n-1 positions.
• If this smallest value is smaller than the value in the first position, exchange the two values.
• At this point, you know the entry in the first position is the smallest, so you can focus on the last n-1 elements.
• Each time you focus on an array that is one smaller, until you are down to just comparing the first two positions.
• To figure out how many comparisons it takes to sort the array:
  • When the array was size n, it took n-1 comparisons.
  • When the array was size n-1, it took n-2 comparisons.
  • etc.
  • The total is 1 + 2 + 3 + ... + n-1 = n(n-1)/2.
• The selection sort is O(n²).

public int findPositionMin(int [] x, int fill) {
   int posMinSoFar = fill
   for (int i = fill; i < x.length; i++)
       if (x[i] < x[posMinSoFar])
          posMinSoFar = i;
   return posMinSoFar;
}

 
public void selectionSort(int [] x) {
   
   for (int fill = 0; fill < x.length - 1; fill++) {
       int posMin = findPositionMin(x, fill + 1);
       if (x[posMin] < x[fill] {
          int temp = x[fill];
          x[fill] = x[posMin];
          x[posMin] = temp;
       }
   }
}