Recurrence Relations with Multiparameter Functions

I have been trying to wrap my head around the concept of a recurrence relation and I see how to divide, conquer and combine. What I am failing to understand is how to derive a proper recurrence relation from a multi argument function that deals with an array of values, a lowest index, and a highest index.

More context: My base case is when the lowest index is equal to the highest index. When that condition is met I return the the element from the lowest index. (Which is also the highest) It is the only element.

My recursive case is when q and p are not equal. Here is the code below:

```int maximum(int[] A, int p, int q) {
if (p == q) {
return A[p];
}
int k, l, max1, max2, max3;
k = p + Math.floor((q-p+2)/3);
l = k + Math.floor((q-p+2)/3);
max1 = maximum(A, p, k-1);
max2 = maximum(A, k, l-1);
max3 = maximum(A, l, q);
if (max1 >= max2 && max1 >= max3) {
return max1;
} else if (max2 >= max1 && max2 >= max3) {
return max2;
} else {
return max3;
}
}
```

I am not sure how I would go about this. From every example I have seen, I should be using n as my input size and the only parameter I am concerned with is my input size for this.

Would someone be able to explain a best approach to solve for just about any algorithm? I feel like this particular type is getting to me because I am used to seeing simpler recursive functions in the explanations behind recurrence relation.