Problems with understanding recursion - recursion

Question

I have problems with understanding recursion, I don't get the explanations in books and tutorials. The example below finds the greatest value in a list, here I get stuck at the second line, I simply don't understand what is happening after max([H|T], Max) when H > Max ->
I would really appreciate if I could get an explanation of all the steps in the code, for instance why it goes -> max(T, H); and -> Max.
max([H|T]) -> max(T, H).
max([H|T], Max) when H > Max -> max(T, H);
max([_|T], Max) -> max(T, Max);
max([], Max) -> Max.
Many thanks!
E.

Answer 1

I tried to explain step by step. Let's assume that you have a list: [2, 3, 1]
max([2, 3, 1]).
H=2 , T=[3, 1]
max([H|T]) -> max(T, H).
H=3, T=[1], Max=2
max([H|T], Max) when H > Max -> max(T, H);
Here when block says: if H is greater than Max then call max function again as max([1], 3).
Here we are again but with different values:
H=1, T=[], Max=3
max([H|T], Max) when H > Max -> max(T, H);
1 > 3 is false so when block fails and trying next max function definition which leads to step 5.
We know H is less than Max because step 4 failed so we are ignoring it.
T = [], Max=3
max([_|T], Max) -> max(T, Max);
We are matching last function definition which says max element found:
[] = [], Max = 3
max([], Max) -> Max.

Answer 2

Best way to understand recursion is by visualizing it. Let me give you a very simple example:
Suppose you want to know what is eligibility to become a prime minister of US, which is:
You have to be national citizen of US, for which here is the rule:
You are a natural born of US (or)
Your parents are national citizen of US
Now, first option straight forward makes you citizen of US, or same whole thing applies to your parents, which may again check for their parents ..and so on.
So there will be a straight forward answer, which is here 1st option. That is called Base Case. And in 2nd option you might apply same process of checking citizenship for your parents.
Here is a very simple pseudo code that can explain recursion:
isEligibleForPrimeMinister checkCitizenship(You, yourParents){
Base Case {returns true(That you are US citizen)}
checkCitizenship(yourParents, YourGrandParents)
}
Hope this helps.

Answer 3

This function could be rewritten like this:
max([H|T]) -> max(T, H).
max([], Max) -> Max;
max([H|T], Max) ->
NewMax = if H > Max -> H;
true -> Max
end,
%% NewMax = erlang:max(H, Max),
max(T, NewMax).
To understand it you must know how pattern matching works.
We take the head element of the list and consider it current maximum. We need to look at all the rest elements that are in the tail and check if any of them is greater.
If the rest of the list is empty, the current maximum is the result.
If the list is not empty take new head and determine the new maximum. Then go on with the rest of the list and new maximum. The thing that must be noticed here is that list passed to the next iteration of max/2 is always the tail of the previously passed value so we don't check values we already saw.

Answer 4

The last three lines in your code are all different clauses of the same function (max/2). This means that whenever the max function is called with two arguments passed, it will be pattern-matched against these three clauses.
This clause:
max([_|T], Max) -> max(T, Max);
will match whenever the list is non-empty and the head of the list (H) is less than or equal to Max. It will call max/2 passing T which is a list and Max which is a number. This new call will also be pattern-matched against the three clauses.
This clause:
max([], Max) -> Max.
will match whenever the list is empty and will return just Max which is a number.