Lecture 9: Binary Chop What is Binary Chop about?

Course: Software Engineering 

Lecture 9: Binary Chop 

Aims and Objectives 

• Define the binary chop algorithm for searching sorted arrays. 

• Illustrate, through this example, 

» the importance of loop invariants for program correctness 

» a problem solving method, called divide and conquer. 

Lecture 9: Binary Chop Slide Number 1 


What is Binary Chop about? 

Problem: Given a sorted array A of integers and an integer x, 

find whereabouts in A the element x occurs. 

If A isn't sorted, there’d be little alternative to inspecting all 

the elements of A one by one until x is found. 

When A is sorted, we can be smarted! 

Rough idea: 

• Look at the element half way along A. 

• If this is bigger than x, then x must be in the first half. 

• If it is smaller, then x must be in the last half. 

• Either way, we have cut the search area by a factor of 2. 

• Repeat this until x is found. 


Binary chop is a very useful algorithm for searching sorted arrays. In this lecture we will show 

the process of defining a specification for such algorithm, and the definition of the algorithm 

with the reasoning steps needed to prove its correctness with respect to the specification. 

The algorithm reflects a fundamental problem solving technique, called divide and conquer, 

which consists of having a big problem difficult to solve, divide it into several parts, solve 

each (smaller) part separately (easier than the original), and hence conquer (i.e. solve) the 

original problem. 

1 

2


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. 


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



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


Second Problem – What about if x 

occurs more than once in the array? 

i. A is ordered, so all the occurrences will be together. 

» Would we like result to be the index of the first or the last? 

ii. Choose the first, so that result is the smallest index. 

iii. result defines boundary between elements < x and those =x. 

iv. This matches our choice for when x doesn’t occur at all. 

So in all possible cases… 

r is the smallest index where the array element is =x, 

or A.length if all the elements are < x. 

A: 

All elements x 

0 result (A.length)-1 



SPECIFICATION – FINAL ATTEMPT 

int Search(int[] A, int x){ 

//pre: Sorted(A) i.e. 

//i.e. ∀i, j.( 0


A Rough Diagram 

Keep two variables, Left and Right, to show how far we’ve narrowed 

the search area. result must be between Left and Right. 

A: 

Rigth-Left >=1 

0 

All elements = x 

Right 

(A.length)-1 


Producing the Code (1) 

• Loop Invariant: 

(0



• Initialisation (establishing the invariant) 

Initially, set: 

Left =0; 

Right = A.length; 

If (A[Left] >= x) then return Left; 

// A[Left] < x; 

After this initialisation, the invariant is satisfied: 

• The third line of the loop invariant is satisfied, as there no integers i such that 

Right



• Re-establishing the invariant (continued) 

Three things need still to be proved: 

• 0


Documentation 

• All serious programs have to be “documented”, i.e. there has to be a written 

explanation of what they do and how they [are supposed to] work. 

• This is usually incorporated as comments. 

• The comments in Search should show the level of detail that is most useful. 

• They shouldn’t give a full formal proof, but must show the most important 

steps. 

• If a formal correctness proof is required, the comments indicate how it 

would be constructed. 

• But even if not, the loop invariant gives a solid framework in which to 

understand the working of the program. 

• If there’s a suspicion of a mistake, or if someone else is trying to understand 

your code, the framework immediately suggests specific 

• Questions: e.g. Does the loop body re-establish the invariant? Is the 

variant decreased each time? Are array accesses OK? 


THE CODE FOR BINARY CHOP 

int Search ([int[ ] A, intx){ 

% Pre: Sorted(A) 

%Post:see slide 6 

int Left = 0; int Right = A.length; int Middle; 

if A[Left] >= x then return Left; 

While (Right-Left>1){ //A[Left] < x; 

% Loop invariant : see slide 8 

% Loop variant = Right – Left – 1 

Middle = (Left+Right) div 2; // Left < Middle < Right 

if (A[Middle]< x) Left = Middle; 

else (Right = Middle);} 

return Right 

} 



13 

14


Conclusion 

• The usual pitfall with the binary chop algorithm lies in not 

being quite sure what the values of Left and Right are 

supposed to mean. 

• Making the specification and the loop invariant precise, and being 

careful about the difference between < and

Lecture 9: Binary Chop What is Binary Chop about?

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?