Worksheet 26: Ordered Bag using a Sorted Array Name:
An Active Learning Approach to Data Structures using C
1
Worksheet 26: Ordered Bag using a Sorted Array
In Preparation: Read Chapter 8 to learn more about the Bag data type and Chapter 9 to
learn more about the advantages of ordered collections. If you have not done it
previously, you should review Chapter 2 on the binary search algorithm, and do Lessons
14 and 16 to learn about the basic features of the dynamic array.
In an earlier lesson you encountered the binary search algorithm. The version shown
below takes as argument the value being tested, and returns, in O(log n) steps, either the
location at which the value is found, or if it is not in the collection the location the value
can be inserted and still preserve order.
Notice that the value
returned by this function
need not be a legal index. If
the test value is larger than
all the elements in the
array, the only position
where an insertion could be
performed and still preserve
order is the next index at
the top. Thus, the binary
search algorithm might
return a value equal to size,
which is not a legal index.
If we used a dynamic array as the underlying container, and if we kept the elements in
sorted order, then we could use the binary search algorithm to perform a very rapid
contains test. Simply call the binary search algorithm, and save the resulting index
position. Test that the index is legal; if it is, then test the value of the element stored at the
position. If it matches the test argument, then return true. Otherwise return false. Since
the binary search algorithm is O(log n), and all other operations are constant time, this
means that the contains test is O(log n), which is much faster than the bags developed in
Lessons 21 and 22.
Inserting a new value into the ordered array is not quite as easy. True, we can discover
the position where the insertion should be made by invoking the binary search algorithm.
But then what? Because the values are stored in a block, the problem is in many ways the
opposite of the one you examined in Lesson 21. Now, instead of moving values down to
delete an entry, we must here move values up to make a “hole” into which the new
element can be placed:
int binarySearch (EleType * data, int size, EleType testValue) {
int low = 0;
int high = size;
int mid;
while (low < high) {
mid = (low + high) / 2;
if (LT(data[mid], testValue))
low = mid + 1;
else
high = mid;
}
return low;
}
