使用struct和递归查找整数数组中的最大数字

Question

I'm required to use recursion to find the largest number in an integer array. Also, I need to get both the value and index of the largest number. I used "struct" but it gave me some weird number and I cannot figure out why.

Here's my struct:

struct maxNumber
{
    int index;
    int value;
};

Here's my find_largest function:

maxNumber Numbers::find_largest()
 {
      maxNumber max;

      int current ;//keep track of the current counter

      if(size == 1)
      {
          max.value = numArray[0];
          max.index = 0;
          return max;
      }

      if(current < size && size != 0)  //loop through all numbers in the array
      {
          if(numArray[current] >= max.value)
           {
            max.value = numArray[current];
            max.index = current;
           }

       current++;
       find_largest();
       }


       return max;
 }

Then, in the main function, I just did this:

int result = num.find_largest().value;
cout << "The largest number is " << result << endl; 

However, it gives me a very large number. Need some help to figure out what's wrong.

Answer 1

Your main problem is that current has local storage and thus is reallocated on every call to findLargest . Change the declaration to this

static int current = 0;

and it should work, if size and numArray are defined properly elsewhere in the class definition.

But the same thing is happening more subtly with max , and it should be declared statically as well.

Answer 2

Just got this fixed. The problem is as what @stvcisco said: I didn't pass the parameters in the function, so it just call the function within itself again and again. Here's the fixed code.

 maxNumber Numbers::find_largest(maxNumber max, int size)
{
    if(size == 1)
    {
        max.value = numArray[0];
        max.index = 0;
    }

    if( size > 1)  //loop through all numbers in the array
    {
        if(numArray[size-1] >= max.value)
        {
            max.value = numArray[size-1];
            max.index = size-1;
            return max = find_largest(max, size-1);
        }
        //return max = find_largest(max, size-1);

        else
        {
            size--;
            find_largest(max,size);
        }

    }


    return max;
}