1
00:00:01,230 --> 00:00:02,130
Hola y bienvenidos.

2
00:00:02,160 --> 00:00:04,920
Vamos a ver a continuación el tema de funciones recursivas.

3
00:00:04,920 --> 00:00:05,770
Están listas?

4
00:00:05,790 --> 00:00:06,240
Vamos.

5
00:00:07,170 --> 00:00:07,380
Bien.

6
00:00:07,380 --> 00:00:10,140
Básicamente el tema de funciones recursivas es muy sencillo.

7
00:00:10,290 --> 00:00:12,970
Sin embargo, también puede ser algo confuso al principio.

8
00:00:13,080 --> 00:00:17,550
Por ello, vamos a ver los temas más importantes relacionados al tema de funciones recursivas.

9
00:00:17,850 --> 00:00:23,070
Básicamente, una función recursiva, como vamos a ver, es una función que se manda llamar a sí misma.

10
00:00:23,370 --> 00:00:28,740
Así que dentro de la función que estamos definiendo vamos a volver a mandar, a llamar la función que

11
00:00:28,740 --> 00:00:30,240
hemos definido anteriormente.

12
00:00:30,450 --> 00:00:35,250
Así que, básicamente el concepto fundamental de una función recursiva es que es una función que se

13
00:00:35,250 --> 00:00:36,600
manda llamar a sí misma.

14
00:00:36,810 --> 00:00:42,180
Sin embargo, existen algunas reglas para poder definir correctamente una función recursiva y evitar

15
00:00:42,180 --> 00:00:47,640
caer en llamadas infinitas, ya que también podríamos crear funciones recursivas que se mandan a llamar

16
00:00:47,640 --> 00:00:48,850
de manera infinita.

17
00:00:48,930 --> 00:00:53,430
Y esto obviamente crearía un problema en la ejecución del programa, ya que la idea de las llamadas

18
00:00:53,430 --> 00:00:56,490
recursivas es que en algún momento se detenga esta ejecución.

19
00:00:56,580 --> 00:01:00,780
Vamos a ver entonces estas reglas para definir correctamente una función recursiva.

20
00:01:01,020 --> 00:01:04,200
Así que vamos a ver reglas para definir funciones recursivas.

21
00:01:04,410 --> 00:01:09,150
La primera regla es que una función recursiva se debe de mandar a llamar a sí misma.

22
00:01:09,360 --> 00:01:13,920
Esto ya lo hemos comentado, pero es la primera regla que debe de cumplir una función recursiva.

23
00:01:14,250 --> 00:01:19,860
Así que dentro de nuestro código de la función vamos a volver a mandar, a llamar nuestra función pasando

24
00:01:19,860 --> 00:01:20,940
cierta información.

25
00:01:20,940 --> 00:01:23,760
Pero esta información normalmente va a estar modificada.

26
00:01:23,760 --> 00:01:28,500
No va a ser exactamente el mismo argumento que vamos a pasar cada vez que mandamos a llamar nuestra

27
00:01:28,500 --> 00:01:29,460
función recursiva.

28
00:01:29,640 --> 00:01:34,440
Sin embargo, la primera característica de una función recursiva es que se mande a llamar a sí misma

29
00:01:34,440 --> 00:01:36,030
dentro del código de la función.

30
00:01:36,390 --> 00:01:42,030
Y como segunda regla es que siempre que mandemos a llamar la función recursiva de alguna manera y de

31
00:01:42,030 --> 00:01:45,210
manera eventual, debe ir avanzando hacia un caso base.

32
00:01:45,690 --> 00:01:49,350
Y una vez que llegamos al caso base, se detienen las llamadas recursivas.

33
00:01:49,500 --> 00:01:52,260
De esta manera vamos a evitar caer en ciclos infinitos.

34
00:01:52,410 --> 00:01:56,850
Así que, por ejemplo, si tenemos una función que recibe un valor, por ejemplo, en este caso el valor

35
00:01:56,880 --> 00:02:03,030
en cualquier variable de tipo entero, entonces de alguna forma, dentro de nuestro código de esta función

36
00:02:03,030 --> 00:02:04,800
vamos a revisar un caso base.

37
00:02:04,860 --> 00:02:09,900
Por ejemplo, si el valor de N es igual a uno, entonces quiere decir que ya hemos llegado al final

38
00:02:09,900 --> 00:02:11,430
de la ejecución de nuestra función.

39
00:02:11,640 --> 00:02:15,930
Por lo tanto, realiza una tarea, por ejemplo, en este caso regresar algún valor o mandar a imprimir

40
00:02:15,930 --> 00:02:16,920
cierta información.

41
00:02:16,920 --> 00:02:19,440
Pero ya no vuelve a mandar a llamar a la misma función.

42
00:02:19,590 --> 00:02:24,160
Así que si coincide que es el caso base, se detiene la ejecución de las llamadas recursivas.

43
00:02:24,210 --> 00:02:29,850
Pero por otro lado, si no es el caso base, entonces volvemos a mandar a llamar la función de manera

44
00:02:29,850 --> 00:02:30,480
recursiva.

45
00:02:30,660 --> 00:02:35,130
Pero aquí lo común es que el argumento va a modificar su valor para que de manera eventual.

46
00:02:35,130 --> 00:02:39,990
Entonces, por ejemplo, si es un valor positivo, vayamos reduciéndolo hasta que lleguemos al valor

47
00:02:39,990 --> 00:02:40,480
de uno.

48
00:02:40,530 --> 00:02:42,520
Por lo tanto, esta es la siguiente condición.

49
00:02:42,540 --> 00:02:48,780
Cada vez que mandemos a llamar, nuestra función recursiva debe estar acercándose al caso base y entonces

50
00:02:48,780 --> 00:02:53,130
mandamos a llamar de nueva cuenta la función y se vuelve a revisar si es el caso base.

51
00:02:53,130 --> 00:02:58,380
Entonces se detiene las llamadas recursivas y si no, entonces se vuelve a llamar de manera recursiva,

52
00:02:58,380 --> 00:03:04,140
pero reduciendo en uno o modificando de alguna manera el argumento para que nos acerquemos al caso base.

53
00:03:04,470 --> 00:03:08,220
Así que con cada llamada recursiva nos acercamos al caso base.

54
00:03:08,700 --> 00:03:12,000
Esas son las reglas que debemos de cumplir cuando trabajamos con funciones recursivas.

55
00:03:12,180 --> 00:03:15,510
Vamos a poner en práctica un ejemplo para que todo esto quede más claro.

56
00:03:15,690 --> 00:03:17,220
Así que nos vemos en el siguiente vídeo.

57
00:03:17,340 --> 00:03:17,940
Saludos.
