CS 250 Computer Programming and Problem Solving - FALL 1998 

[ Home | Syllabus | Notes | Glossary | CS250 WEB Version Home Page | Project Page | Final Study Guide]

Searching: A Common Problem

Search an array for the smallest element.

• How would you do this "by hand"

int FindMin(int a[ ], int start, int end)
// PRE: a is an array with elements defined between a[start] and a[end]
//	and start <= end
// POST: return the location of the minimum value in the array between a[start] and a[end]
{
	int min = a[start]; // guess it is the first element
	int where = start;	// and remember where you found it

	for(int i = start+1; i <= end; i++)
		if(a[i] < min) {
			min = a[i];
			where = i;
		}
	return where;
}

How Much Work?

• Clearly we have to look at every element
• If there are 5 elements, we need to do 4 comparisons in the loop
• In general, we need to do n-1 comparisons with n array elements to examine.
• This algorithm takes more work, the larger the array
• If you double the number of elements between start and finish, how much more work is there to do?
• This algorithm is linear in its computation workload.
• Can you find a better algorithm?

Searching for a particular element in an array

• Element may NOT be in the list
• We need not search the whole list if the element is found "early"

const int NOT_FOUND = -1;	// an impossible index value

int Find(int a[ ], int x, int start, int end)
// PRE: a is an array with elements defined between a[start] and a[end]
//	and start <= end
// POST: return the location of the element "x" in the array between a[start] and a[end]
//	if exists, else return NOT_FOUND
{
	
	for(int i = start; i <= end; i++)
		if(a[i] == x)
			return i;
	return NOT_FOUND;
}

How Much Work?

• Similar to FindMin in many ways (compare the for loops).
• But there are two cases to analyze.

  What is the element "x" is NOT in the list?

  • Clearly you have to examine the entire list to know that (if unordered).
  • You have to test (with the "==") all elements.
  • If you double the number of elements, you double the work.
  • This is also a "linear" algorithm

  What if the element "x" IS in the list?

  • Well you can stop as soon as you find it.
  • When will that be? It depends
    • If you are very lucky, you will find it right away (one test)
    • If you are very unlucky, you will find it in the last position (n tests)
    • But on the average, you find it in the middle (n/2 tests).
• Can you find a better algorithm?
  (well you wouldn't want to search a phone book this way)

Binary Search: Searching a Sorted List

• How would you search a phone book?
• What would be the fastest way to search it?
• There are two cases
  • when the name is on the page you selected
  • and when it is not (in this case consider the similar but smaller problem of searching half the book.
• How long will it take to find the right page?
• what happens when the size of the phone book doubles?

int RFind(int a[ ], int x, int start, int end)
// PRE: a is an array with elements defined between a[start] and a[end]
//	and start <= end
//	Array "a"  is sorted
// POST: return the location of the element "x" in the array between a[start] and a[end]
//	if exists, else return where it should be placed
{
	if(start == end)		// one element arrays are easy (BASE CASE)
		return start;
	int middle = (start+end)/2;	// find the middle of the sub- array
	if(x < a[middle])	// must be in the first "half" of the array
		return RFind(a,x,start,middle);		// narrow the search to first half
	else if(x > a[middle])	must be in the second "half"
		return RFind(a,x,middle+1,end);
	else
		return middle;	// here it is!
}

Copyright chris wild 1998.
For problems or questions regarding this website contact [Chris Wild (e-mail:wild@cs.odu.edu].
Last updated: December 04, 1998.