








































Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity
Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium
Prepara tus exámenes
Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity
Prepara tus exámenes con los documentos que comparten otros estudiantes como tú en Docsity
Encuentra los documentos específicos para los exámenes de tu universidad
Estudia con lecciones y exámenes resueltos basados en los programas académicos de las mejores universidades
Responde a preguntas de exámenes reales y pon a prueba tu preparación
Consigue puntos base para descargar
Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium
Comunidad
Pide ayuda a la comunidad y resuelve tus dudas de estudio
Ebooks gratuitos
Descarga nuestras guías gratuitas sobre técnicas de estudio, métodos para controlar la ansiedad y consejos para la tesis preparadas por los tutores de Docsity
El concepto de recursividad en programación, su demostración por inducción y su uso en algoritmos como la solución estructurada y no estructurada del factorial, la ejecución de un módulo recursivo y la traza de algoritmos recursivos. También incluye ejemplos de aplicaciones recursivas como el producto, la suma y la búsqueda de elementos en un vector, así como algoritmos más complejos como la búsqueda binaria recursiva y la ordenación rápida.
Tipo: Apuntes
1 / 48
Esta página no es visible en la vista previa
¡No te pierdas las partes importantes!









































Metodolog´ıa de la Programaci´on II
Entender el concepto de recursividad.
Conocer los fundamentos del dise˜no de algoritmos recursivos.
Comprender la ejecuci´on de algoritmos recursivos.
Aprender a realizar trazas de algoritmos recursi- vos.
Comprender las ventajas e inconvenientes de la recursividad.
Ventajas: No es necesario definir la secuencia de pasos exacta para resolver el problema.
Desventajas: Podr´ıa ser menos eficiente.
Para que una definici´on recursiva est´e completa- mente identificada es necesario tener un caso base que no se calcule utilizando casos anteriores y que la divisi´on del problema converja a ese caso base.
Ejemplo:
xn^ =
1 si n = 0 x · xn−^1 si n > 0
Ejemplo: C´alculo del factorial con n=3.
3! = 3 * 2! 3! = 3 * 2! 2! = 2 * 1!
3! = 3 * 2! 2! = 2 * 1! 1! = 1 * 0!
3! = 3 * 2! 2! = 2 * 1! 1! = 1 * 0! (caso base)0! = 1 (3) (4)
3! = 3 * 2! 2! = 2 * 1! 1! = 1 * 1 1
3! = 3 * 2! 2! = 2 * 1 1! = 1 * 1 = 1
3! = 3 * 2 2! = 2 * 1 = 2
3! = 3 * 2 = 6
Casos generales: Si el problema es suficientemente complejo, la soluci´on se expresa, de forma recur- siva, como la uni´on de
&
$
%
Los casos generales siempre deben avanzar hacia un caso base. Es decir, la llamada recursiva se hace a un subproblema m´as peque˜no y, en ´ultima instancia, los casos generales alcanzar´an un caso base.
Ejemplo:
// Solucion no estructurada int factorial (int n) { if (n==0) //Caso base return 1; else //Caso general return n*factorial(n-1); }
// Solucion estructurada int factorial (int n) { int resultado; if (n==0) //Caso base resultado = 1; else //Caso general resultado = n*factorial(n-1); return resultado; }
Llamada: x = factorial(3);
factorial n = 3 x=factorial(3); x=factorial(3);
factorial n = 3
factorial n = 2
x=factorial(3);
factorial n = 3
factorial n = 1 factorial n = 2
factorial n = 1
x=factorial(3);
factorial n = 3
factorial n = 2
factorial n = 0
factorial n = 1
x=factorial(3);
factorial n = 3
factorial n = 2
1
x=factorial(3);
factorial n = 3
factorial n = 2
1
x=factorial(3);
factorial n = 3
2
x=factorial(3); 6 (7) (8)
Ejemplo: Averigua qu´e hace este algoritmo
int Recursivo (int *V, int i1, int i2) { int aux1, aux2;
if (i1==i2) //Caso base return V[i1]; else { //Caso general aux1 = Recursivo(V, i1, (i1+i2)/2); aux2 = Recursivo(V, ((i1+i2)/2)+1, i2); if (aux1>aux2) return aux1; else return aux2; }
llamada: Recursivo(V,0,3), con V es [3,7,0,1]
0 1 2 3
(^9)?
Recursivo(v,0,3)
i1=0,i2=(0+3)/2= Recursivo(v,0,1)
3
i1=0,i2=(0+1)/2=
0 1
aux
1 1 7
i1=((0+1)/2)+1=1,i2=
devuelve: Recursivo (v, 0, 1) =
Recursivo(v,0,0) 0 devuelve:
0 3
Recursivo(v,1,1)
v 3 7 0 1
(i1!=i2)
(i1!=i2)
(i1=i2)
(i1=i2)
3
devuelve:
aux2 7 7
aux1 7
i1 0 i
v i1 i
v
v (^) i1 i
v i1 i
xn^ =
1 si n = 0 x · xn−^1 si n > 0
int potencia(int base, int expo){ if (expo==0) return 1; else return base * potencia(base,expo-1); }
suma(a, b) =
a si b = 0 1 + suma(a, b − 1) si b > 0
int suma(int a, int b){ if (b==0) return a; else return 1+suma(a,b-1); }
producto(a, b) =
{ 0 si b = 0 a + producto(a, b − 1) si b > 0
int producto(int a, int b){ if (b==0) return 0; else return a+producto(a,b-1); }
sumaV (V, n) =
{ V [0] si n = 0 V [n] + sumaV (V, n − 1) si n > 0
int SumaV (int *V, int n){ if (n==0) return V[0]; else return V[n]+sumaV(V,n-1); }
M ayor2(V, i, d) =
=
V [i] si i = d M ayor2(V, i, (i + d)/ 2 ´o M ayor2(V, ((i + d)/2) + 1, d) si i < d
int Mayor2 (int *V, int izq, int der) { int m_izq, m_der; if (izq==der) return V[izq]; else { m_izq = Mayor2(V, izq, (izq+der)/2); m_der = Mayor2(V, ((izq+der)/2)+1, der); if (m_izq> m_der) return m_izq; else return m_der; } }
BusquedaLineal(V, n, b) =
=
Verdad si V [n] = b Falso si V [0] 6 = b (V [n] == b) ´o (b ∈ {V [0],... , V [n − 1]}) en otro caso
int BusquedaLineal(int *V, int n, int b) { if (n<0) return 0; else if (V[n]==b) return 1; else return BusquedaLineal(V,n-1,b); }