Every recursion problem must have a base case. This is to ensure that recursion will stop at a certain level. In this case, the base case is when the second parameter of the function multiply is 1. Here's a more detailed diagram on the recursion algorithm.

multiply ( 3, 5) → multiply (3,4) + 3 → multily (3, 3 ) + 6 → multiply (3,2) + 9 →multiply (3,1 ) + 12

multiply (3, 1) will return 3 as shown in the function above. So,

multiply (3,1) + 12 → 3 + 12 → 15.

Do you get recursion now?

No? Never mind, let me give you another example.

Do you know what is factorial ? Factorial is the product of all positive integers less or equal to n. The symbol for factorial is '!'. So, 4! is equal to 4 * 3 * 2 * 1. We can use recusive function to find the value of n!.

factorial(n) :

if n less or equal to 1 :

return 1

else :

return ( n * factorial (n-1))

Let's say we input n as 5. Then the sequence to solve the problem is,

factorial(5) → 5 * factorial(4) → 5 * 4 * factorial(3) → 5 * 4 * 3 * factorial(2) → 5 * 4 * 3 * 2 * factorial(1) → 5 * 4 * 3 * 2 * 1 → 120

As you can see, the base case is when n is 1 or less. This is proven as the recursion stop when the n is 1.

There are three conditions to use a recursion algorithm.

1) There is a base case.

2) Work toward the base case.

3) The function calls itself.

I had already explained the need for a base case. I will now explain about the second condition. Look at both of the recursion algorithms above. The recursion caused the inputs to be closer to the base case each time the function is called. This is important as we do would not want an function which work away from the base case each time it calls itself. This is bad as we would never be able to solve the problem!

The main reason to use recursion is to make the code more readable and simpler as we allowed the function to call itself.