recursive function to locate last occurence of an element - c

Question

I am trying to write a recursive function in C,
Given an array, size of the array as well as the element int target, I want to find the index of int target's last occurence.
#include <stdio.h>
int rLookupAr(int array[], int size, int target);
int main()
{
int numArray[80];
int target, i, size;
printf("Enter array size: \n");
scanf("%d", &size);
printf("Enter %d numbers: \n", size);
for (i=0; i < size; i++)
scanf("%d", &numArray[i]);
printf("Enter the target number: \n");
scanf("%d", &target);
printf("rLookupAr(): %d", rLookupAr(numArray, size, target));
return 0;
}
int rLookupAr(int array[], int size, int target)
{
}
However, I have been stuck for hours.
I am a beginner to recursive functions and any help will be greatly appreciated!
Some examples:
Enter array size:
5
Enter 5 numbers:
2 1 3 2 4
Enter the target number:
2
rLookupAr(): 3

Answer 1

If you're after the last occurrence, then you can start your search at the end of the array and work backwards.
C arrays are referenced by a pointer to any element and a length or index upper-bound value, which you have.
One way of looking at recursive functions is asking "is each step of the algorithm just repeating the whole thing, just on a decreasing subset of the input data?" - consider problems like processing trees (where each child node is a tree itself) or operations like quicksort (where each pivot gives you two more sub-sections which you pivot again, and so on).
Consider that finding a value in an array of [0...N] is the same as finding the value by checking [0] and then checking [1...N], then repeating yourself all over again by checking [1] and then checking [2..N]...hopefully you're seeing a pattern emerging.
For working backwards, given the array's start and length N, you'd check [N] first, then repeat with the range [0..(N-1)], then check [N-1] then repeat with [0...(N-2)].
I hope that will enable you to come to a solution without me just giving you the answer.

Answer 2

You can define rLookupAr() function as following. See the complete working code here:
int rLookupAr(int array[], int size, int target)
{
if(size < 1) return -1;
size--;
if(array[size] == target) return size;
return rLookupAr(array, size,target);
}
Note: rLookupAr() function will return -1 if target value is not found in array array.
OUTPUT:
Enter array size: 5
Enter 5 numbers: 2 1 3 2 4
Enter the target number: 2
rLookupAr(): 3
Following is the complete code:
#include <stdio.h>
int rLookupAr(int array[], int size, int target);
int main()
{
int numArray[80];
int target, i, size;
printf("Enter array size: \n");
scanf("%d", &size);
printf("Enter %d numbers: \n", size);
for (i=0; i < size; i++)
scanf("%d", &numArray[i]);
printf("Enter the target number: \n");
scanf("%d", &target);
printf("rLookupAr(): %d", rLookupAr(numArray, size, target));
return 0;
}
int rLookupAr(int array[], int size, int target)
{
if(size < 1) return -1;
size--;
if(array[size] == target) return size;
return rLookupAr(array, size,target);
}

Answer 3

Please find the recursive function below:
int rLookupAr (int array[], int size, int target)
{
if(size<=0) return -1;
if(array[size-1] == target)
return size-1;
else
return rLookupAr (array, size-1, target); //recurse
}
basically the functions starts from the end because the last occurance is being sought. Depending on whether the target is found or not it further recurses down the array.
Complete code:
#include <stdio.h>
int rLookupAr (int array[], int size, int target);
int
main ()
{
int numArray[80];
int target, i, size;
printf ("Enter array size: \n");
scanf ("%d", &size);
printf ("Enter %d numbers: \n", size);
for (i = 0; i < size; i++)
scanf ("%d", &numArray[i]);
printf ("Enter the target number: \n");
scanf ("%d", &target);
printf ("rLookupAr(): %d", rLookupAr (numArray, size, target));
return 0;
}
int
rLookupAr (int array[], int size, int target)
{
if(size<=0) return -1;
if(array[size-1] == target)
return size-1;
else
return rLookupAr (array, size-1, target); //recurse
}
Output:
Enter array size:
5
Enter 5 numbers:
2
1
3
2
4
Enter the target number:
2
rLookupAr(): 3

Answer 4

Here is a solution with a single statement:
int rLookupAr(int array[], int size, int target) {
return size-- <= 0 ? -1 : array[size] == target ? size : rLookup(array, size, target);
}
Using a recursive solution for a simple case like this is only meant as an exercise. C compilers are not required to perform tail recursion optimization to convert this code to a loop, so this recursive implementation can easily cause a stack overflow for a moderately large array.

Answer 5

I am a beginner to recursive functions
Recursive functions get a bad name with linear reduction.
Instead break the problem in 2 to achieve a a recursive depth of log2(n).
int rLookupAr(int array[], int size, int target) {
if (size < 1) {
return -1;
}
int mid = size/2;
int right = rLookupAr(array + mid, size - mid, target);
if (right != -1) {
return right + mid;
}
int left = rLookupAr(array, mid, target);
return left;
}

Answer 6

int rLookupAr(int input[], int size, int x) {
/* Don't write main().
Don't read input, it is passed as function argument.
Return output and don't print it.
Taking input and printing output is handled automatically.
*/
if(size==0)
{
return -1;
}
//return -1;
int ans=lastIndex(input+1,size-1,x);
if(ans!=-1)
{
return ans+1;
}
else{
if(input[0]==x)
{
return ans+1;
}
else
{
return -1;
}
}
}

Answer 7

int lastIndex(int input[], int size, int x)
{
if (size == 0)
{
return -1;
}
int answer = lastIndex(input + 1, size - 1, x);
if (answer != -1)
{
return answer + 1;
}
if (input[0] == x)
{
return 0;
}
else
{
return -1;
}
}
int main()
{
int input[] = {9, 8, 10, 8};
int x = 8;
int size = 4;
cout << lastIndex(input, size, x);
return 0;
}