: :
hey, i'm fine. 
: :
: : probably u still have some confusion. inside sum(1), n equals to 1. inside sum(2), n equals to 2... as u know from functions - these are their local parameters.
: :
: : well, if sum(2) [n = 2] has been called, it will return n + sum(1). but where it will find the value of sum(1)? well, it will call the function sum with the parameter 1. then, two copies of the function sum() will remain inside RAM - one is for the call sum(2) and the other is for the call sum(1).
: :
: : when sum(2) is looking for the value of sum(1), sum(2) hasn't finished its execution. even when sum(2) is "evaluating" sum(1) by calling "itself," sum(2) is still in the memory and hasn't finished its execution. so in this sum(2) sum(1) case, there are two copies of n in memory, one is holding the value 2, the other is 1, for sum(2) and sum(1) respectively.
: :
: : sum(1) returns 1, causing sum(2) to return 2 + sum(1) which is 2 + 1. so no change of n inside sum(2).
: :
: : now guess what will happen in the call sum(100). sum(100) will call sum(99), sum(99) will call sum(98), ..., sum(2) will call sum(1), sum(1) will return 1. when sum(1) starts execution, there are 100 copies of sum inside RAM and thus 100 copies of n are there to hold the values 100 through 1.
: :
: : i'm sleepy, so there might be mistakes in my explanation. forgive me for that 
: :
: :
~Donotalo()
: :
: :
:
: Hi Donotalo
:
: Brilliant!! Now I got it completely!!
: Great explanation. Now I knew where I was misunderstanding was that the statement of,
:
: return n + sum(n-1)
:
: sum(n-1) is INDEED the another function (that's why it's a recursive function) to be called and to return it's own local value.
:
: At here,
:
: return n + sum(n-1)
:
: Each function is returning it's own different local value which is also the
parameter of each different functions.
:
: Thanks for clarifying my misunderstanding.
: This will make my further study far more interesting and easy. :)
:
:
: Cheers!
:
: PS: Hope you will get a good sleep. ;)
:
but tokoG, one precaution u shud take while programming a recursive function. sometimes it is easy to think recursively and thus it is easy to design a recursive function. but a recursive function may take much more memory than its iterative version. so a recursive function may exhaust memory. though memory shud not be a concern in today's computers, u shud be careful while designing a recursive function in professional life.
~Donotalo()
