Ordered Binary Search w/ Assembly | Recursive vs. Iterative vs. Library - c++

Question

Which is better?
According to Savitch, each recurse is saved on the stack in the form of an activation frame. This has overhead. However it takes a few less lines of code to write a recursive version. For an interview which one is better to turn in. The code for both is below.
#include <iostream>
using namespace std;
const int SIZE = 10;
int array[ SIZE ] = { 0,1,2,3,4,5,6,7,8,9 };
int answer = NULL;
void binary_search_recursive( int array[], int start, int end, int value, int& answer )
{
int mid = (start + end ) / 2;
if ( array[ mid ] == value )
{
answer = mid;
}
else if ( array[ mid ] < value )
{
binary_search_recursive( array, mid + 1, end, value, answer );
}
else
{
binary_search_recursive( array, start, mid - 1, value, answer );
}
}
void binary_search_iterative( int array[], int start, int end, int value, int& answer )
{
int mid = ( (start + end ) / 2 );
while( array[ mid ] != value )
{
if ( array[ mid ] < value )
{
start = mid;
mid = ( ( ( mid + 1 ) + end ) / 2 );
}
else
{
end = mid;
mid = ( ( start + ( mid - 1 ) ) / 2 );
}
}
answer = mid;
}
int main()
{
binary_search_iterative( array, 0, SIZE - 1, 4, answer);
cout << answer;
return 0;
}

Answer 1

Recursive versions of algorithms are often shorter in lines of code but iterative versions of the same algorithm are often faster because of the function call overhead of the recursive version.
Regarding the binary search algorithm, the faster implementations are written as iterative. For example Jon Bentley's published version of the binary search is iterative.

Answer 2

In case of a binary search recursion does not help you express your intent any better than the iteration does, so an iterative approach is better.
I think the best approach for an interview would be to submit a solution that calls lower_bound: it shows the interviewer that you not only know some basic-level syntax and how to code a freshman-year algorithm, but that you do not waste time re-writing boilerplate code.

Answer 3

For an interview, I'd start by mentioning that both recursive and iterative solutions are possible and similarly trivial to write. Recursive versions have a potential issue with nested stack frames using or even exhausting stack memory (and faulting different pages into cache), but compilers tend to provide tail recursive optimisations that effectively create an iterative implementation. Recursive functions tend to be more self-evidently correct and concise, but aren't as widely applicable in day to day C++ programming so may be a little less familiar and comfortable to maintenance programmers.
Unless there's a reason not to, in a real project I'd use std::binary_search from <algorithm> (http://www.sgi.com/tech/stl/binary_search.html).
To illustrate tail recursion, your binary_search_recursive algorithm was changed to the assembly below by g++ -O4 -S. Notes:
to get an impression of the code, you don't need to understand every line, but the following helps:
movl are move statements (assignments) between registers and memory (the trailing "l" for "long" reflects the number of bits in the registers/memory locations)
subl, shrl, sarl, cmpl are subtraction, shift right, shift arithmetic right, and compare instructions, and the important thing to note is that as a side effect they set a few flags, such as "equals" if they produce a 0 result, that is consulted by je (jump if equals) and jge (jump if greater or equal), jne jump if not equal.
the answer = mid termination condition is handled at L10, while the recursive steps are instead handled by the code at L14 and L4 and may jump back up to L12.
Here's the disassembly of your binary_search_recursive function (the name is mangled in C++ style)...
__Z23binary_search_recursivePiiiiRi:
pushl %ebp
movl %esp, %ebp
pushl %edi
pushl %esi
pushl %ebx
subl $4, %esp
movl 24(%ebp), %eax
movl 8(%ebp), %edi
movl 12(%ebp), %ebx
movl 16(%ebp), %ecx
movl %eax, -16(%ebp)
movl 20(%ebp), %esi
.p2align 4,,15
L12:
leal (%ebx,%ecx), %edx
movl %edx, %eax
shrl $31, %eax
leal (%edx,%eax), %eax
sarl %eax
cmpl %esi, (%edi,%eax,4)
je L10
L14:
jge L4
leal 1(%eax), %ebx
leal (%ebx,%ecx), %edx
movl %edx, %eax
shrl $31, %eax
leal (%edx,%eax), %eax
sarl %eax
cmpl %esi, (%edi,%eax,4)
jne L14
L10:
movl -16(%ebp), %ecx
movl %eax, (%ecx)
popl %eax
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
.p2align 4,,7
L4:
leal -1(%eax), %ecx
jmp L12

Answer 4

You use iteration if speed is an issue or if the stack size is constraining, because as you said it involves calling the function repeatedly which results in it occupying more space on the stack. As for answering in the interview I would go for whichever I feel is simplest to do correctly at that time, for obvious reasons :))