Binary search implemention ( mostly code structure problems, aka newbie problems) - c

Question

I have just learned my very first steps in C (I used to code in python) and as a such I'm facing great difficulty with the syntax, and as well as with binary search implementation. (I'm new to programming.)
So here's my code:
#include <stdlib.h>
#include <stdio.h>
#define size 1000
int binary_search(int array[size], int givenNumber) {
do {
int start = 0;
int end = size;
int middle = start + end / 2;
int left = size - 1;
int right = size + 1;
if (array[middle] == givenNumber) {
printf("location: %d, number: %i", middle, givenNumber);
return middle;
} else if (array[left] < givenNumber) {
int start = 0;
int end = array[left];
int middle = start + end / 2;
return middle;
} else if (array[right] > middle) {
int start = array[right];
int end = size;
int middle = start + end / 2;
return middle;
} else {
return -1;
break;
}
}
} while (int middle != givenNumber)
int main() {
int sorted_array[size];
for (int i = 0; i < size; i++) {
sorted_array[i] = i;
}
return binary_search(sorted_array, 349);
}
My problems are:
1 - when compiling, the error is something along the lines of "in while block "middle" isn't defined"
I have no clue on why the value isn't passing from the do block to the while block. Note that I added "return middle" to each if / else-if block, as I I thought it may help.
2- I'm not even quite sure if my own implementation of this binary search is correct. I have looked up how to implement it but I found it next to impossible to read the syntax, this is just to give a heads up.
UPDATE:
I have reconstructed the whole code according to the notes users have given in the answers below, and well, my algorithm is working and now it could find any number in any given array, however I'm unable to figure out a way to tell if the array doesn't have that givenNumber as it would get eventually stuck.
Here's an input/output:
int array[size] = {1,2,3,4,5,6,8,9,10,11,14,24,53,100};
function: binary_search(array, 24);
output: Location: 11, Number: 24
Which is pretty good, however if I enter a number which doesn't exist in the array, the loop continues to search endlessly (gets stuck in recursion)
here's the updated code:
#include <stdio.h>
#include <stdlib.h>
#define size 14
int start = 0;
int end = size -1;
int middle;
int left;
int right;
int binary_search(int array[size], int givenValue)
{
middle = (start + end) / 2;
printf("\nstart: %d \nend: %d \nmiddle: %d \n\n",start, end, middle);
do
{
if (start > end)
{
printf("item isn't found");
break;
return -1;
}
middle = (start+end)/2;
left = middle -1;
right = middle +1;
if (array[middle] == givenValue)
{
printf("Location: %d, Number: %d", middle, givenValue);
return middle;
break;
}
if(array[middle] > givenValue)
{
end = right;
return binary_search(array, givenValue);
}
if(array[middle] < givenValue)
{
start = left;
return binary_search(array, givenValue);
}
}
while (start <= end);
}
int main(void)
{
int array[size] = {1,2,3,4,5,6,8,9,10,11,14,24,53,100};
return binary_search(array, 24);
}
My condition is that if start is greater than end then the item doesn't exist, and it doesn't work at all because left/right keeps getting stuck at the same values (Run the code to know what I mean)
How do I fix this issue?

Answer 1

There are a number of issues:
The loop does not iterate. All parts of if/else have a return
massive amount of "shadowing" of variables
size is invariant so left/right are always set to the same thing
left and right should be started at 0 and size - 1 respectively
variables are used inconsistently (e.g. start is both an array index and an array value)
The function is more complex than it needs to be and has some extraneous variables
Your binary search algorithm is suspect
First and foremost, I'd recommend removing all "sub-scoped" variable declarations that shadow outer scoped ones (i.e. put all variables at the outermost scope).
Do this until you're more comfortable with these declarations. Learn more about the difference between:
variable declaration: int x;
variable declaration with initializer: int x = 5;
variable assignment: x = 5;
I've annotated your original function, created a test/diagnostic function and created a refactored function that passes the diagnostic test:
#include <stdio.h>
#define size 1000
int
binary_fixed(int *array, int givenNumber)
{
int left;
int right;
int middle;
int curval;
int retindex = -1;
left = 0;
right = size - 1;
while (left <= right) {
middle = (left + right) / 2;
curval = array[middle];
if (curval == givenNumber) {
retindex = middle;
break;
}
if (curval > givenNumber)
right = middle - 1;
else
left = middle + 1;
}
return retindex;
}
int
binary_search(int *array, int givenNumber)
{
int middle;
// NOTE/BUG: this does _not_ iterate
// NOTE/BUG: _massive_ amount of "shadowing" of variables
// NOTE/BUG: size is _invariant_ so left/right are _always_ set to the
// same thing
// NOTE/BUG: left and right should start at 0 and size - 1 respectively
// NOTE/BUG: variables are used _inconsistently_ (e.g. start is both
// an array index and an array _value_)
do {
int start = 0;
int end = size;
int middle = start + end / 2;
int left = size - 1;
int right = size + 1;
if (array[middle] == givenNumber) {
printf("location: %d, number: %i\n", middle, givenNumber);
return middle;
}
else if (array[left] < givenNumber) {
int start = 0;
int end = array[left];
int middle = start + end / 2;
return middle;
}
else if (array[right] > middle) {
int start = array[right];
int end = size;
int middle = start + end / 2;
return middle;
}
else {
return -1;
}
} while (middle != givenNumber);
printf("BADRETURN givenNumber=%d\n", givenNumber);
}
int sorted_array[size];
void
test(const char *who,int (*fnc)(int *,int))
{
int i;
int r;
for (i = 0; i < size; i++) {
r = fnc(sorted_array, i);
if (r != i) {
printf("ERROR -- EXPECTED: %d ACTUAL: %d (from %s)\n", i, r, who);
// break;
}
}
}
int
main()
{
for (int i = 0; i < size; i++) {
sorted_array[i] = i;
}
//test("ORIGINAL",binary_search);
test("FIXED",binary_fixed);
return 0;
}
UPDATE:
Since you're coming from python, here are a few points that may help with your understanding.
Arrays are passed to functions as pointers, so in the function argument list, int *array is equivalent. Doing int array[size] is an advanced technique. Avoid it for now. In C, you can't do array.count as you can in python. So, for now, pass the count as an additional argument.
Pointers are something that python doesn't have, so you'll have to learn about how to use them. Once you get the hang of them, they are quite powerful and can make code run quite fast.
In C [and most languages except python [and php]], the default scope is global. It's the reverse of python. In python, unless you specify global x, then x is private to the function. In other languages, to have x be local to the function, you have to declare it at function scope.
In C, all variables must be declared somewhere: global scope, function scope [or a block scope within a function], or as an argument. And, each declaration must specify an explicit type. There is no equivalent of javascript's declaration of var x. After that, x could be either a string or a value depending upon what you set it to: (e.g. x = 23 or x = "abc")
In C, x must be given a type such as: int x; or double x; or int *x; or char *x.
Here is your revised code with annotations:
#include <stdio.h>
#include <stdlib.h>
// NOTE: this is hardwired
#define size 14
// NOTE: this is _global_ scope -- while not absolutely wrong, using function
// scope below is faster/better and provides better isolation -- this doesn't
// scale as well
int start = 0;
int end = size - 1;
int middle;
int left;
int right;
// NOTE: in C, using "int *array" is equivalent [and in many cases preferred]
// NOTE: the array count should be passed in as a separate argument
int
binary_search(int array[size], int givenValue)
{
// NOTE: this is _function_ scope
// NOTE: this calc of middle is extraneous because it is recalculated
// below
middle = (start + end) / 2;
printf("\nstart: %d \nend: %d \nmiddle: %d \n\n", start, end, middle);
// NOTE/BUG: this function combines _both_ a loop implementation and a
// recursive implementation -- we have to pick one or the other as trying
// to do both messes things us -- the recursion is broken [see below]
// NOTE: this loop checks start vs end _twice_ in the loop -- it only
// needs to check in one place -- convert this to "while (start <= end) {"
// instead of a "do {...} while (whatever);" loop [which is usually not
// as good]
do {
if (start > end) {
printf("item isn't found");
break;
// NOTE/BUG: this return will _never_ be executed because we
// break out of the loop and what is worse we'll return an
// unknown/undefined value because
return -1;
}
middle = (start + end) / 2;
// NOTE/BUG: these are reversed
left = middle - 1;
right = middle + 1;
if (array[middle] == givenValue) {
printf("Location: %d, Number: %d", middle, givenValue);
return middle;
break;
}
// NOTE/BUG: these recursive calls do nothing because they do _not_
// further limit the scope and cause infinite recursion -- to make
// a recursive version work, start/end would need to be arguments:
// return binary_search(array,givenValue,start,end)
// and we shouldn't loop -- the recursive calls just aren't needed
// NOTE/BUG: the tests here are broken -- they are the reverse of
// the correct ones
if (array[middle] > givenValue) {
end = right;
return binary_search(array, givenValue);
}
if (array[middle] < givenValue) {
start = left;
return binary_search(array, givenValue);
}
// NOTE/BUG: this extra test is extraneous and would be done too late
// if the array size was zero -- a case that isn't handled here
} while (start <= end);
// NOTE/BUG: when we break out of the loop, we need to return _some_ value
// here -- this would be flagged by the compiler using the -Wall option
}
int
main(void)
{
int array[size] = { 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 14, 24, 53, 100 };
// NOTE/BUG: the return value from main can only handle numbers 0-255
// better to print the return value
return binary_search(array, 24);
}
Here is a working version of your revised code.
The loop is now a simple while. The function takes a separate count argument. It loops instead of recurses. The reversed if logic has been fixed. Again, a diagnostic test has been added.
#include <stdio.h>
#include <stdlib.h>
int
binary_search(int *array, int size, int givenValue)
{
// NOTE: this is _function_ scope
int start = 0;
int end = size - 1;
int middle;
int left;
int right;
int match_index;
// assume failure
match_index = -1;
// NOTE: this calc of middle is extraneous because it is recalculated
// below
middle = (start + end) / 2;
printf("\nstart: %d \nend: %d \nmiddle: %d \n\n", start, end, middle);
while (start <= end) {
middle = (start + end) / 2;
left = middle - 1;
right = middle + 1;
if (array[middle] == givenValue) {
printf("Location: %d, Number: %d\n", middle, givenValue);
match_index = middle;
break;
}
if (array[middle] > givenValue) {
end = left;
}
if (array[middle] < givenValue) {
start = right;
}
}
if (match_index < 0)
printf("match not found -- givenValue=%d\n",givenValue);
return match_index;
}
int
main(void)
{
int array[] = { 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 14, 24, 53, 100 };
int count = sizeof(array) / sizeof(array[0]);
int curidx;
int valwant;
int match;
printf("%d\n",binary_search(array, count, 24));
// run diagnostic on all values
for (curidx = 0; curidx < count; ++curidx) {
// get value to search for
valwant = array[curidx];
match = binary_search(array,count,valwant);
if (match != curidx) {
printf("fault: curidx=%d valwant=%d match=%d\n",
curidx,valwant,match);
}
}
// test lower range failure
valwant = array[0] - 1;
match = binary_search(array,count,valwant);
if (match >= 0)
printf("fault: valwant=%d match=%d\n",valwant,match);
// test upper range failure
valwant = array[count - 1] + 1;
match = binary_search(array,count,valwant);
if (match >= 0)
printf("fault: valwant=%d match=%d\n",valwant,match);
return 0;
}

Answer 2

A typical binary search implementation would either loop or recurse until the number is found. The naive recursive code is something like this:
#include <stdio.h>
#define size 1000
int binary_search(int array[size], int givenNumber, int start, int end) {
int middle;
middle = (start + end) / 2;
if (start > end)
return -1;
if (array[middle] == givenNumber) {
printf("location: %d, number: %i", middle, givenNumber);
return middle;
} else if (array[middle] < givenNumber) {
return binary_search(array, givenNumber, middle + 1, end);
} else { // if (array[middle] > givenNumber)
return binary_search(array, givenNumber, start, middle - 1);
}
}
int main() {
int sorted_array[size];
for (int i = 0; i < size; i++) {
sorted_array[i] = i * 2;
}
if (binary_search(sorted_array, 349, 0, size - 1) < 0) {
printf("value not found\n");
}
if (binary_search(sorted_array, 34, 0, size - 1) < 0) {
printf("value not found\n");
}
}
Notice in the recursion we call binary_search each time with a new start and end range based on the sorted array and the provided input in givenNumber.

Answer 3

You can't declare a variable inside a while statement. Move it to the top of your function.
You have a misplaced curly brace in your code.
Try this:
#include <stdlib.h>
#include <stdio.h>
#define size 1000
int binary_search(int array[size], int givenNumber) {
int middle;
do {
int start = 0;
int end = size;
int middle = start + end / 2;
int left = size - 1;
int right = size + 1;
if (array[middle] == givenNumber) {
printf("location: %d, number: %i", middle, givenNumber);
return middle;
} else if (array[left] < givenNumber) {
int start = 0;
int end = array[left];
int middle = start + end / 2;
return middle;
} else if (array[right] > middle) {
int start = array[right];
int end = size;
int middle = start + end / 2;
return middle;
} else {
return -1;
}
} while (middle != givenNumber);
}
int main() {
int sorted_array[size];
for (int i = 0; i < size; i++) {
sorted_array[i] = i;
}
return binary_search(sorted_array, 349);
}