Question

I am trying to write an iterative search in a C program.

The pseudo-code would look like this for it:

while length of list > 0

look at middle of list

if number found, return true

else if number is too high, only consider

left half of list

else if number is too low, only consider

right half of list

return false

I have already implemented a bubble sort (which I assume works). Here is my code right now. The search is currently linear. I need to somehow change it to a binary search (I would prefer to do it iteratively instead of recursively). I’m completely lost on how I should go about doing this though. Can someone please help me?:

#include <cs50.h>
#include <stdio.h>
#include <stdlib.h>

#include "helpers.h"

/*
 * Returns true if value is in array of n values, else false.
 */

bool 
search(int value, int array[], int n)
{

// TODO: re-implement as binary search
int min = 0;
int max = n;
int i;

i=(min+max)/2;
    if(array[i] == value)
        {
        return true;
        }
    else if(min>=max)
        {
        return 1;
        }
    else if(array[i] > value)
        {
        max = i-1;
        }    
    else if(array[i] < value)
        {
        min = i+1;
        }
    return false;
}



/*
 * Sorts array of n values.
 */

void 
sort(int values[], int n)
{
//set smade to false to start
//declares the_end as n-1
bool smade = false;
int the_end = n-1;

// TODO: implement an O(n^2) sort
while(the_end > 0)
{
    for(int i = 0; i < the_end; i++)
    {
        int temp;
        if (values[i] > values[i+1])
        {
            temp = values[i];
            values[i] = values[i+1];
            values[i+1] = temp;
            smade=true;
        }
    

}
if(! smade)
    {
    break;
    }
the_end--;
}
return;
}

Answer 1

You just translate your pseudo-code into code. I’ll give you some more refined pseudo-code:

1) Set minimum possible location for thing we’re looking for (min) to zero.

2) Set maximum possible location for thing we’re looking for (max) to the highest-possible location.

3) Compute a location loc as (min+max)/2.

4) Check if loc holds the object we’re looking for. If so, stop, we found it.

5) Check if min>=max. If so, stop, it’s not here.

5) If the object at loc is too high, set max to loc-1. (Because the maximum location at which it could be is one less than loc, since loc is too high.)

6) If the object at loc is too low, set min to loc+1. (Same logic, the other way around.)

7) Go to step 3.