如何使用递归 function 在数组中返回 integer 的索引？

Question

i have to find the index of an integer in an array using a recursive function this is what i have up to now:

#include <iostream>

int linear_search(int array[], int choice_, int size) {

    if (array[choice_] >= 0) {
        return array[choice_];
    }
    else {
        return -1;
    }
}

for example if the:

 int array[]= {3,4,7,8};

if i type that i want to search for number 3 it should give me the index of 0 but instead it gives me the number 8. can i get some advise please?

Answer 1

Recursion is about narrowing down a problem to a smaller problem.

In the case of this particular search, try to think of it in terms of the found-item being either in the first position in the array, or maybe in the remainder of the array. This then reduces the problem to searching a smaller array, until you either find the item or you hit the trivial case of an empty array.

int linear_search(int array[], int choice_, int size)
{
    // Array is empty -- not found
    if (size <= 0)
        return -1;

    // Found at position 0
    if (array[0] == choice_)
        return 0;

    // TODO: Search position in remaining array
    int pos = linear_search(/* USE BRAIN HERE */);

    // TODO: You may want to do something to the result before returning it

    return pos;
}

As you can see, I've left some parts for you to fill in. I have faith in you. You can do it!

Happy coding!

Answer 2

This is binary search. It is a recursive function.

int binary_search_recursive(const int b[], int search_key, int low, int high)  
{  
    if (low > high)  
        return -1;  

    int mid = low + (high - low) / 2;  

    if (search_key == b[mid])  
        return mid;     
    else if (search_key < b[mid])  
        return binary_search_recursive(b, search_key, low, mid - 1);    
    else  
        return binary_search_recursive(b, search_key, mid + 1, high);  
} 

Answer 3

This code is wrong

if (array[choice_] >= 0) {
    return array[choice_];

When you do array[choice_] you are looking at the array value at index choice_ . That is not what you want. Instead you want to find out if the array at some index is equal to choice_ . That would be if (array[some_index] == choice_) return some_index;

Further, to make this a recursive approach, the function needs to call itself. Your code doesn't do that so it's not recursive.

Here is a recursive approach:

int searchArray(const int* array, const int choice_, const int size)
{
    if (size > 0)
    {
      if (array[size-1] == choice_) return size-1;  // Hit! Return the index
      return searchArray(array, choice_, size-1);   // Recursive call - pretend array is 1 shorter
    }
    return -1;
}

The code looks at the last element in the array.

• If it is a hit it simply returns the index.

• If it is not a hit, it calls itself but decrements size to pretend that the array is one element shorter.

In this way it goes from the end of the array towards the start of the array while looking for choice_ .

BTW: Notice that it's a very bad idea to use recursion for this task - never do that! Use a simple for loop. But I guess this is just another example of a very bad homework task...