递归方法的结果

Question

I am trying to understand this recursive method but even with a debugger I couldn't come up to something that makes sense to me so i hope someone here is motivated to explain me what is going on here. I know how recursion works basically but the way this method is written down troubles me. I know the conditional operator in java and I worked out a new code but still I don't understand it, so what I expect here is.

What is the result for m(5) AND m(15). How did you calculate it? Thanks

Edit after the answers. I made a table with my results for future readers

m(n)::|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|...
result|0|0|1|1|1|2|3|4|6|9|13|19|28|41|60|88|...

I checked only the result of 15 with my program.

public class practice {

    /**
     * Try to understand the way this works
     * @param n
     * @return 
     */
    static long m(long n) {
        return n <= 1 ? 0 : n == 2 ? 1 : m(n - 1) + m(n - 3);
    }

    /**
     * This is what i tried so far.
     * @param n
     * @return 
     */
    static long ma(long n) {

        System.out.println("Method called");
        System.out.println("N is: " + n);
        if (n <= 1) {
            System.out.println("N<=1: " + n);
            System.out.println("0 is returned");
            return 0;
        } else if (n == 2) {
            System.out.println("N==2: " + n);
            System.out.println("1 is returned");
            return 1;
        } else {
            System.out.println("Inside ELSE, N is: " + n);
            return ma(n - 1) + ma(n - 3);
        }
    }

    public static void main(String[] args) {
        ma(15);
    }

}

Answer 1

Wrote it this way to make it more understandable:

m(0) = 0
m(1) = 0
m(2) = 1
m(n) = m(n - 1) + m(n - 3) // n >= 3

When we know the values for m(0) , m(1) and m(2) , we can calculate any m(n) , where n >= 3 , using m(n - 1) + m(n - 3) . For any negative input, the result is 0.

For example:

m(3) = m(3 - 1) + m(3 - 3) = m(2) + m(0) = 1 + 0 = 1
m(4) = m(4 - 1) + m(4 - 3) = m(3) + m(1) = 1 + 0 = 1
m(5) = m(5 - 1) + m(5 - 3) = m(4) + m(2) = 1 + 1 = 2

And so on...

Answer 2

Pencil and paper are you friends.

There are 3 cases (two of them are base conditions)

if n <= 1  then return 0

if n == 2 then return 1

else recursive call to  m(n-1) + m(n-3)

So you know that on every recursive call we are approaching one of the base conditions.

Here is a stack trace of what happens on m(5)

                                m(5)
                    m(4)         +          m(2)
        m(3)         +      m(1)            return 1
m(2)     +      m(0)        return 0
return 1        return 0

Adding all the returns gives 1 + 0 + 0 + 1 which is 2

So

m(5) == 2

Answer 3

Method m in pseudo code. (this is some kind of scala/python mash up)

def m (number n)
    if (n <= 1)       0
    else if (n == 2)  1
    else              m(n - 1) + m(n - 3)

Looking at this you can see that anything <= 2 is a terminal operation, returning 0 or 1 based on the input. If n is > 2, the fun begins. Take for example n=3 . Since 3 is greater than 2 , we need to run the third if . When we look at that line we see that we nee to return m(n - 1) + m(n - 3) . Plugging n = 3 in, it looks like this: m(3 - 1) + m(3 - 3) , or, more simplified, like this: m(2) + m(0) . This will now terminate with 1 because neither 2 or 0 for n will result in more calling of m .

So now we have something we understand we can now workout what m(15) and m(5) will return.

I will only work it out for 5 since the call stack for 15 would be way to long

                   m(5)
              /           \
           m(5-1)   +    m(5-3)
        /         \         |
      m(4-1)  +  m(4-3)     |
    /       \       |       |
  m(3-1) + m(3-3)   |       |
    |        |      |       |
    1    +   0   +  0   +   1
                 2

Hope it helps!

Answer 4

m(5) = m(4)+m(2) // 5>2, so the third condition
m(4) + m(2) = m(3)+m(1) + 1 // 4>2, so the third condition
m(3) + m(1) + 1 = m(2)+m(0) + 0 + 1 // 3>2, so the third condition
m(2) + m(0) + 0 + 1 = 1 + 0 + 0 + 1 = 2

Now, between transformations, m(2) s instantly replaced with 1 , and m(n<=1) is instantly replaced with 0 . This is how you can analyze this on paper. Computer, however, would wirst calculate m(4) before calculating m(2) and adding the results in the first line - this happens because of order of poerations within the recursive functions.