Call and Search Help

[Happy2bhere]

I need help finishing the calling and searching for the binary and recursive areas. I have linear done but I don't know how to do the other two because of some overlap issues I keep encountering.
Thanks in Advance.

#include <iostream>
#include <string>
#include <chrono>
#include <fstream>
#include <vector>

using namespace std;
using namespace std::chrono;

typedef std::chrono::time_point<system_clock> timer;
typedef double Second;

void TriggerTimer(timer&);
Second TimerCountInSecond(timer, timer);

bool LinearSearch(const vector<int>&, int);
bool BinarySearchRecursive(const vector<int>&, int, int, int);
bool BinarySearch(const vector<int>&, int);
bool ReadFileToVector(vector<int>&, string);
void TimingSearch(const vector<int>&, int, string);

int main()
{
    vector<string> fileNames = {    "data_10_sorted.txt",
                                    "data_2000_sorted.txt" ,
                                    "data_10000_sorted.txt" ,
                                    "data_100000_sorted.txt" };
    for (int i = 0; i < fileNames.size(); i++)
    {
        string fileName = fileNames[i];
        vector<int> sortedData;

        //Populate the vector with data from data file: 
        if (ReadFileToVector(sortedData, fileName) == true)
        {
            string searchType = "linear";
            int notExistItem = 7777777;
            int existItem = sortedData[0.8 * sortedData.size() - 1];
     
            cout << "+++++++++++++++++++++++++++++++++++++" << endl;
            cout << " Searching on " << fileName << endl;
            cout << "+++++++++++++++++++++++++++++++++++++" << endl;

            //0a. Timing LINEAR search for non-existing item:
            TimingSearch(sortedData, notExistItem, searchType);

            //0b. Timing LINEAR search for existing item:
            TimingSearch(sortedData, existItem, searchType);

            //1a. Timing BINARY search for non-existing item:
          
            //1b. Timing BINARY search for existing item:
         
            //2a. Timing BINARY RECURSIVE search for non-existing item:

            //2b. Timing BINARY RECURSIVE search for existing item:

       
        }
    }

	return 0;
}

/*******************************************************************
 *                       LinearSearch                              *
 * Called by: TimingSearch                                         *
 * Passed   : 2 arguments: a vector of numbers,                    *
 *            and the number to search for                         *
 * Purpose  : Determines if the number to search for is in the set *
 *            of stored numbers                                    *
 * Method   : Uses a linear search                                 *
 * Returns  : true (if the number is found) or false (if not found)*
 *******************************************************************/
bool LinearSearch(const vector<int> &numbers, int numToSearch)
{
    bool isFound = false;
    for (int i = 0; i < numbers.size(); i++)
    {
        if (numbers[i] == numToSearch)
        {
            isFound = true;
            break;
        }
    }

    return isFound;
}

/*******************************************************************
 *                       BinarySearchRecursive                     *
 * Called by: TimingSearch                                         *
 * Passed   : 4 arguments: a vector of numbers, the number to      *
 *            search for, the low index, and the high index        *
 * Purpose  : Determines if the number to search for is in the set *
 *            of stored numbers                                    *
 * Method   : Uses a binary search                                 *
 * Returns  : true (if the number is found) or false (if not found)*
 *******************************************************************/
bool BinarySearchRecursive(const vector<int> &numbers, int numToSearch, int low, int high) // High = numbers.size -1 Low= 0
{
    if (low > high)
    {
        return false;
    }

    int mid = (low + high) / 2;
    if (numbers[mid] < numToSearch) 
    {
        return BinarySearchRecursive(numbers, numToSearch, mid + 1, high);
    }
    else if (numbers[mid] > numToSearch) 
    {
        return BinarySearchRecursive(numbers, numToSearch, low, mid - 1);
    }
    else
    {
        return true;
    }
}

/*******************************************************************
 *                       BinarySearch                              *
 * Called by: TimingSearch                                         *
 * Passed   : 2 arguments: a vector of numbers,                    *
 *            and the number to search for                         *
 * Purpose  : Determines if the number to search for is in the set *
 *            of stored numbers                                    *
 * Method   : Uses a binary search                                 *
 * Returns  : true (if the number is found) or false (if not found)*
 *******************************************************************/
bool BinarySearch(const vector<int> &numbers, int numToSearch)
{
    bool isFound = false;
    int mid = 0;
    int low = 0;
    int high = numbers.size() - 1;

    while (high >= low) 
    {
        mid = (high + low) / 2;
        if (numbers[mid] < numToSearch) 
        {
            low = mid + 1;
        }
        else if (numbers[mid] > numToSearch) 
        {
            high = mid - 1;
        }
        else 
        {
            isFound = true;
            break;
        }
    }

    return isFound;
}

void TriggerTimer(timer& timeContainer)
{
    timeContainer = std::chrono::system_clock::now();
}

Second TimerCountInSecond(timer startTime, timer endTime)
{
    std::chrono::duration<Second> elapsed_seconds = endTime - startTime;
    return elapsed_seconds.count();
}

bool ReadFileToVector(vector<int> &numbers, string fileName)
{
    bool isReadGood = false;
    int number;
    fstream inFile;
    inFile.open(fileName, ios::in);
    if (inFile.fail())
    {
        cout << "File open failed." << endl;
    }
    else
    {
        do //Read the file until the end of the file
        {
            inFile >> number;
            numbers.push_back(number);

        } while (inFile.eof() == false);
        isReadGood = true;
    }

    inFile.close();

    return isReadGood;
}

/*******************************************************************
 *                       TimingSearch                              *
 * Called by: main                                                 *
 * Passed   : 3 arguments: a vector of numbers, the number to      *
 *            search for, and the search algorithm to use          *
 * Purpose  : Use a specific search algorithm to show seach        *
 *            runtime                                              *
 * Method   : Uses a search algorithm                              *
 * Returns  : None                                                 *
 *******************************************************************/
void TimingSearch(const vector<int> &sortedData, int searchItem, string searchType)
{
    timer start, end;
    bool isFound = false;    

    TriggerTimer(start);
    if (searchType == "linear")
    {
        isFound = LinearSearch(sortedData, searchItem);
    }
    
    //### binary and recursive search algorithm ###
   
    TriggerTimer(end);
    int toMicroSecond = 1000000;
    cout << "Search Item: " << searchItem << endl;
    cout << "Search Type: " << searchType << " search" << endl;
    cout << "Item found: " << isFound << endl;
    cout << "Elapsed time: " << TimerCountInSecond(start, end) * toMicroSecond << " microsecond(s)" << endl;
    cout << "=====================================" << endl;
}

[salem c]

Please format your post -> https://www.cplusplus.com/articles/jEywvCM9/

[lastchance]

@Happy2bhere,
other than the fact that you don't actually call either BinarySearch or BinarySearchRecursive from anywhere outside, what is your problem? What do you mean by "overlap issues".

[seeplus]

do //Read the file until the end of the file
        {
            inFile >> number;
            numbers.push_back(number);

        } while (inFile.eof() == false);

The ReadFileToVector() also has a problem. It will add a spurious number to the end of the vector.

while (inFile >> number)
    numbers.push_back(number);

[seeplus]

As you're displaying the elapsed time in microseconds, why not have TimerCount return the time in microseconds rather than seconds and then doing a calculation?

double TimerCountInMicro(timer startTime, timer endTime)
{
	return std::chrono::duration<double, std::micro>(endTime - startTime).count();
}

...
cout << "Elapsed time: " << TimerCountInMicro(start, end) << " microsecond(s)" << endl;