Lecture 9: Binary Chop What is Binary Chop about?

Course: Software Engineering
Specification – first attempt
// pre: Sorted(A)
// post: A[result] = x
int Search(int[] A, int x){
…….
}
As usual, result denotes the value returned by the method.
Course: Software Engineering
First Problem – Suppose x is not in A?
What answer would we like?
» We could look for the boundary between the elements < x and
those > x. This would allow, for instance, the method Search to be used for
finding whereabouts in A a new element x could be inserted leaving A sorted.
There are two ways of describing this boundary using result
Way 1: A[result] < x and A[result+1] > x
Way 2: A[result–1] < x, and A[result] > x
Look at the array boundaries:
Way 1
Way 2
All elements of A are >x
result = -1.
result = 0
All elements of A are < x
result = (A.length) -1
result = (A.length)
Way 2 is our standard: result is the smallest index where the array
element is > x (or A.length if all the elements are < x).
Lecture 9: Binary Chop Slide Number 3
Lecture 9: Binary Chop Slide Number 4
We assume for the rest of this lecture that the pre-condition Sorted(A) means implicitly that A is
not null and not empty.
3
Defining a specification of a method with parameters requires thinking about all the possible
parameters’ values that can be passed to the method when it’s used in some other part of a program.
So, in the previous slide we have initially thought of defining the result of the method Search to be
the index of the element x in the array. A first problem that the method search could have in
execution is when the given array does not include the variable x at all. The post-condition of the
method doesn’t say anything about this case. So if we were building the method search using the
specification given in the previous slide our program would not necessarily provide a correct answer
(if any at all!) We need to think then what we want our method to do for the particular case when the
array A does not include x.
A useful thing would be to provide the boundary within the array of where such element should have
been included if it were there. This would for instance allow the method to be used in other methods
that, for instance, need to include an element in a sorted array.
In this case, we can have two different definitions of post-conditions for Search, one which says that
Search returns the index of an element which is smaller than x and such that the next element is
greater than x (way 1) or that Search returns the index of the first element found that is bigger than x
and such that the previous one is an element smaller than x (way 2). How can now choose between
these two different post-conditions? Again what we need to do is think about the possible extreme
cases of values of the parameters. It can well be that the array includes all elements which are
smaller than the given x, or that all its elements are bigger than x. In each of these two cases we need
to see what the boundary values the variable result would assume. Looking at the table given above,
it is clear that using (way 1) approach we would get into trouble when the array includes elements all
smaller than x, because the result would be a negative index, Way 2 instead seems to give acceptable
values for result in both extreme case.
We therefore choose the second type of post-condition: The method will return the index of the
smallest element included in A that is bigger than x, and in case all elements of A are smaller than x
it will return the length of the array.
4