Understanding Double Recursion

Question

I can easily understand recursion if there is only one recursive call in a function. However, I am really embarrassed when I see two or more recursive calls inside the same function. Example:

int MaximumElement(int array[], int index, int n)
    {  
        int maxval1, maxval2; 
        if ( n==1 ) return array[index];
        maxval1 = MaximumElement(array, index, n/2); 
        maxval2 = MaximumElement(array, index+(n/2), n-(n/2));
        if (maxval1 > maxval2)
            return maxval1;
        else
            return maxval2;
    }

I understand one thing, that n decreases by half during each recursive call. I just don't understand how the next recursive call works. It gets confused and my understanding until this point falls apart, and I give up. I would be very grateful if anyone could illustrate this manually with a neat example. I already programmed and printed the outputs. However, I do not understand how the calculations for this work. Here is my understanding until the moment when everything becomes useless:

int a [] = {1,2,10,15,16,4,8}

Initial Call: MaximumElement (a, 0, 7)

: : MaximumElement (a, 0, 7/2) n 7/2 = 3

: MaximumElement (2,0,3/2) n 3/2 = 1

max1 [0] = 1

: 0 n = index + n/2 = 0 + 1/2 = 0? , 3 n, .

, . -, !

, . java, ( , ):

        public int MAXIMUMELEMENT(int a[], int i, int n)
        {
        int max1, max2;

        System.out.println("1: " + i + " 2: " + n);

        if(n == 1)
        {
            System.out.println("Returning " + a[i]);
        return a[i];
        }



        max1 = MAXIMUMELEMENT(a, i, n/2);

        System.out.println("Index: "+i+" "+" Variable: "+max1+" n value: "+n);


            max2 = MAXIMUMELEMENT(a, i + (n/2), n - (n/2));

        System.out.println("Index2: " + i + " " + "Variable2: " + max2);


        if(max1 > max2)
        {
            System.out.println("Returning.... " + max1 );    
                return max1;
        }
        else
        {
        System.out.println("Returning.... " + max2);     
        return max2;
        }
}

Answer 1

, , , - ,

a = [1,2,10,15,16,4,8]

" " :

maxval1 = MaximumElement(array, 0, 3); 
maxval2 = MaximumElement(array, 3, 4);

• maxval1 , 0 3
• maxval2 3 4

,

• maxval1 10
• maxval2 16

16.

, , . , , .

, , , " ", 0. . 3. ( , maxval2).

, . m , maxval1 maxval2 "".

a = [1,2,10,15,16,4,8]

m(a, 0, 7)
= m(m(a, 0, 3), m(a, 3, 4))
= m(m(m(a, 0, 1), m(a, 1, 2)), m(a, 3, 4))
= m(m(a[0], m(a, 1, 2)), m(a, 3, 4))
= m(m(1, m(a, 1, 2)), m(a, 3, 4))
= m(m(1, m(m(a, 1, 1), m(a, 2, 1)), m(a, 3, 4))
= m(m(1, m(a[1], a[2])), m(a, 3, 4))
= m(m(1, m(2, 10)), m(a, 3, 4))
= m(m(1, 10), m(a, 3, 4))
= m(10, m(a, 3, 4))
= …
= 16

Answer 2

, , , . :

public static int getFib(int n) {
    if(n <= 2) return 1;
    return getFib(n-1)+getFib(n-2);
}

, , , , , . , getFib(n-1) n <= 2, , getFib (n-1), getFib (n-2). , 4, :

getFib(4) //Initial call
  getFib(4-1=3) //Left hand recursive call level 1
    getFib(3-1=2) //Left hand recursive call level 2
      return 1 //This would be level 3
    getFib(3-2=1) //Right hand recursive call level 2
      return 1 //level 3
  getFib(4-2=2) //Right hand recursive call level 1
    return 1

, , :
_{(: -40stones.com)}

( ) .

Answer 3

, . , (maxval2) , (maxval1). maxval1 . , maxval2.

Try debugging instead of running the code (for example, in Eclipse) and go step by step to see how this happens with each recursive call.