0:00

Hello and welcome to the lesson devoted to recursion.

We start this lesson with a very soft introduction to recursion.

So imagine a line to a museum.

Imagine a person that just gets in the line, call her Alice.

And she has this natural will to know the number of people before her.

So she asks Bob,

who is the person just right before her,

"Could you please tell me the number of people before you."

So what is important to realize at this point is that

Bob faces exactly the same problem at this point.

So Bob somehow computes the number of people before him is 239, for example.

So at this point,

Alice knows that the number of people before her is equal to 240, right?

And this can be implemented in the following very simple code.

So we call this procedure,

number of people before some person in a line.

So it is implemented as follows,

just this four simple lines of code: If there is nobody before this person,

then we just return zero.

Otherwise there is a person before A,

let's call him B.

So what we do, we first make a recursive call for B.

By saying recursive call,

I mean the code for this,

for exactly the same function because

we need to perform exactly the same computational task.

So we make this call, it returns us some result,

we add one and then we return it, okay?

So another very standard example is the following: it's computing the factorial function.

So the factorial of positive integer n,

it is denoted as follows, so pronounce it n factorial.

Is by definition equal to the product of

all positive integers from 1 to n. So for example,

five factorial is equal to one times two,

times three, times four, times five,

which is equal in turn to one hundred and twenty.

You can notice that it is actually same as one times two, times three,

times four multiplied by five,

but this is just four factorial, right?

Just by definition, right?

So this can be as well expressed as four factorial times five.

And this gives rise to the following recursive definition: So n factorial is

equal to one when n is equal to one,

or it is equal to n times n minus one factorial,

when n is greater than 1.

So it is a recursive definition because it defines n factorial,

so it defines a function in terms of itself.

So it expresses n factorial through n minus one factorial, right?

So the recursive definition defines an object in terms of itself.

The recursive program calls itself.

So when we have such and at the same time you can continue this further, right?

So n minus one factorial is also n minus one times n, minus two factorial.

And n minus two factorial in turn is n minus two times n minus three factorial.

So we somehow need to ensure that this process of calling itself

will terminate at some point and that there will be just a finite number of steps.

So we need to somehow ensure this and we will get back to this just in a minute.

So before this, let's first implement

the very simple program for computing the factorial,

and we first turn its basic definition into an iterative program.

So here, we first make a check of areas in greater than zero,

then we just declare some new variable, which is going to store our result.

And then we iterate all possible values from one to n,

this is down here.

And for each such value,

we multiply the result by it and finally,

we return the result.

So this is iterative program, okay?

In turn, the recursive program gives rise to the following recursive procedure: Again,

we first check that n is greater than zero, right?

Then, if n is equal to one, then we immediately return on.

In this case there is nothing to compute of course.

Otherwise we return n times the factorial of n minus one.

So what will happen here actually during this recursive program is that first,

the factorial of n minus one is going to be computed,

then it will be multiplied by n,

and then it will be returned.

So this way we transform our recursive definition into recursive program and once again,

the way we ensure that the number of recursive calls is

going to be finite in this case is exactly because we have this base case,

the so called base case.

So with each recursive call, n decreases by one.

So eventually, it will hit one and at this point,

our recursive procedure will return one and will stop using new recursive calls, okay?

So termination is important and usually,

it is achieved as we've discussed already,

by keeping track of some parameter and by

ensuring that it always decreases and that at some point it will hit the base case.

Okay? So when we were computing the lengths of the line,

we actually saw why our recursive procedure will eventually stop.

Well, just because with each recursive call,

we get closer to the head of the line.

to put it otherwise, the number of people before the current person,

it always increases by one right with each recursive call.

And it cannot become negative and when it is zero,

we actually return, we stop producing new recursive calls.

And similarly, for n factorial when computing factorial,

n always decreases by one with each recursive call and when its one,

we just return, okay?

Let me also show you several examples of` the recursion of an infinite recursion.

So the first one is shown here.

So here, instead of decreasing n with each recursive call,

we actually increase it.

So what happens here is that it will produce just an infinite number of recursive calls,

an endless process of calling the same procedure.

So in theory, such a program will never stop.

So n will be increased to infinity.

In practice, if you run this program,

so what you get is that it will crash and you will get either stack overflow message or

message like maximum recursion depth exceeded, okay?

A little bit more examples, so for example,

this is the same program for computing factorial where we just forget to add a base case.

So in this case, while this is going to happen,

regard this as an infinite recursion,

so it is going to be infinite just because there is no base case.

If you call for example factorial five,

it will make make a recursive call for factorial four,

then factorial three, factorial two, factorial one,

then factorial zero minus one, minus two, minus three and so on. It will never stop.

Another possibility of infinite recursion is the following,

8:28

So in this case we have some base case, however,

we do not change the parameter,

the parameter does not decrease.

So if you call factorial five, it will call factorial five again, and again, and again,

and again, and again, so forever.

Finally, two more jokey examples.

So there is a standard joke that to understand recursion,

you must first understand recursion,

which again puts you into an infinite loop.

So if you would like to start understanding recursion,

according to this rule,

you must first understand recursion,

but to understand recursion, you must first understand recursion and so on.

And finally, an example by Google.

You know that in Google there is this spell checking property,

a suggesting product feature,

which if you make a typo in your search query,

it will fix it for you and that's whether you mean the following.

So if you type recursion,

the Google will ask you, did you mean recursion and this is clickable actually,

and if you click, you will get to the same page

and it will ask you again and then you will click again,

and again, and again, an endless number of times.