Algoritmos y Programación II

Universidad Nacional de San Antonio de Areco

(UNSAdA)
Clase 7
Algoritmos Recursivos
En la clase de hoy veremos…

Ejemplos de Aplicación

Algoritmos Recursivos
aplicados a Arreglos
 Ejercicio 1
Realice un módulo que calcule la cantidad de dígitos pares que tiene un
número que recibe como parámetro, en forma recursiva.
¿Qué recibe ?
¿Qué debe devolver como resultado ?

Solución Iterativa (num>0)

FUNCION cantidadPares ( num: Entero): Entero

DATOS
cant,dig: Entero ¿Qué devuelve en caso NUM = 0?
COMENZAR Solución (num >=0)
cant = 0
Mientras (num <> 0) FUNCION cantidadDigitosPares(num:Entero): Entero
dig = num mod 10 COMENZAR
Si (dig mod 2 == 0) Si (num == 0)
cant ++ cantidadDigitosPares = 1
num = num div 10 Sino
cantidadPares = cant cantidadDigitosPares = cantidadPares(num)
FIN FIN
Ejemplos de Aplicación
 Ejercicio 1
Solución Recursiva (num>0)

Pasos a seguir:
cantidadPares(412) = 1 + cantidadPares(41) Dig = 2
¿Planteo de la solución
cantidadPares(41) = 0 + cantidadPares(4) Dig = 1
en base a problema más
cantidadPares(4) = 1 + cantidadPares(0) Dig = 4 chico ?
cantidadPares(0) = 0
¿Caso Base?

¿Cómo achico el
problema?

0 Si (num=0)

1 + cantidadPares(num div 10) Si (num>0) y (ult dig par)

cantidadPares(num)
cantidadPares(num div 10) Si (num>0) y (ult dig impar)
 Ejercicio 1
Solución Recursiva (num >0)

0 Si (num=0)
cantidadPares(num) 1 + cantidadPares(num div 10) Si (num>0) y (ult dig par)
cantidadPares(num div 10) Si (num>0) y (ult dig impar)

FUNCION cantidadPares ( num: Entero ) : Entero Num= 412

DATOS Dig = 2 1
dig: Entero cantidadPares(412)= 1+ cantidadPares(41) =
2
COMENZAR
Si (num == 0)
cantidadPares = 0 {caso base} Num= 41
Sino Dig = 1 1
dig = num mod 10 cantidadPares(41)= cantidadPares(4) =1
Si (dig mod 2 == 0)
cantidadPares = 1 + cantidadPares (num div 10) {Llamada recursiva}
Num= 4
Sino Dig = 4
cantidadPares = cantidadPares (num div 10) {Llamada 0
recursiva}1+ cantidadPares(0)
cantidadPares(4)= = 1
FIN

Solución para num >= 0,

Llamar a cantidadPares desde la función Num= 0
8
cantidadPares(0)= 0 Caso base
cantidadDigitosPares implementada en diapositiva 5
 Ejercicio 2
Realice un módulo que calcule la cantidad de dígitos pares y la cantidad de
dígitos impares que tiene un número que recibe como parámetro, en forma
recursiva.
¿Qué recibe ?
¿Qué debe devolver como resultado ?

Solución iterativa ¿Qué devuelve en caso NUM = 0?

PROCEDIMIENTO cantidadParImp (E num: Entero, ES imp: Entero, ES par: Entero)

DATOS
dig: Entero Solución
COMENZAR PROCEDIMIENTO ParesImpares(E num: Entero, ES imp : Entero, ES par: Entero)
Mientras (num <> 0) COMENZAR
dig = num mod 10 imp = 0
Si (dig mod 2 == 0) Si (num == 0)
par ++ par = 1
Sino
Sino par = 0
imp ++ cantidadParImp (num, imp, par)
num = num div 10 FIN
FIN
 Ejercicio 2

Realice un módulo que calcule la cantidad de dígitos pares y la cantidad de

dígitos impares que tiene un número que recibe como parámetro, en forma
recursiva.
Solución Recursiva (num >0)

PROCEDIMIENTO cantidadParImp(E num: Entero, ES imp: Entero, ES par: Entero)

DATOS
dig: Entero Solución num >= 0
COMENZAR PROCEDIMIENTO ParesImpares(E num: Entero, ES imp: Entero,
Si (num <> 0) par: Entero)
dig = num mod 10 COMENZAR
Si (dig mod 2 == 0) imp = 0
par ++ Si (num == 0)
Sino par = 1
imp ++ Sino
num = num div 10 par = 0
cantidadParImp(num, imp ,par) cantidadParImp(num, imp, par)
FIN FIN
Algoritmos Recursivos
aplicados a Arreglos
 Ordenación rápida: QuickSort

QuickSort divide el vector en dos partes que se ordenan

recursivamente. Se puede resumir en tres pasos:

1. Escoger un Elemento de Pivote.

2. Particionar el vector en dos partes: una cuyos elementos

son menores que el pivote, otra cuyos elementos son
mayores.

3. Ordenar cada partición de manera recursiva con

QuickSort.
 Ordenación rápida: QuickSort

PROCEDIMIENTO QuickSort(v: vector; izquierdo, derecho: Entero)

DATOS
posicionPivote : Entero
COMENZAR
posicionPivote = particionar(v, izquierdo, derecho)
Si (izquierdo >= derecho)
//No hacer nada, intervalo ya ordenado
Sino
Si (izquierdo < posicionPivote – 1)
QuickSort(v, izquierdo, posicionPivote - 1)

Si (derecho > posicionPivote)

QuickSort(v, posicionPivote, derecho)
FIN
 Ordenación rápida: QuickSort

FUNCION Particionar(v: vector, izquierdo: Entero, derecho: Entero): Entero

DATOS
valorPivote, temporal: Entero
COMENZAR
valorPivote = v[ (izquierdo + derecho) / 2 ]
Mientras (izquierdo <= derecho)
Mientras (v[izquierdo] < valorPivote)
izquierdo++

Mientras (v[derecho] > valorPivote)

derecho--

Si (izquierdo <= derecho)

temporal = v[izquierdo]
v[izquierdo] = v[derecho]
v[derecho] = temporal
izquierdo ++
derecho --
Particionar = izquierdo
FIN
 Ordenación rápida: QuickSort

http://www.algostructure.com/sorting/quicksort.php
 Ordenación por intercalación: MergeSort

MergeSort es un algoritmo recursivo para ordenar los

elementos de un vector.

Primero se divide el vector en dos partes iguales.

Después se ordenan las dos partes recursivamente.

Finalmente se combinan las dos partes ordenadas para

obtener el resultado.
Ordenación por intercalación: MergeSort

PROCEDIMIENTO MergeSort(v: vector, izq: Entero, der: Entero)

DATOS
medio: Entero

COMENZAR
Si (der > izq)
medio = (der + izq) / 2
MergeSort(v, izq, medio)
MergeSort(v, medio+1, der)
MergeSort = Combina(v, izq, (medio + 1), der)
FIN
 Ordenación por intercalación: MergeSort
PROCEDIMIENTO Combina (v : vector, izq: Entero, med: Entero, der: Entero)

DATOS
temp: vector
izq_fin, num_elementos, tmp_pos: Entero

COMENZAR
izq_fin = (med - 1)
tmp_pos = izq
num_elementos = (der - izq + 1)

Mientras ((izq <= izq_fin) AND (med <= der))

Si (vector[izq] <= vector[med])
temp[tmp_pos++] = vector[izq++]
Sino
temp[tmp_pos++] = vector[med++]

Mientras (izq <= izq_fin)

temp[tmp_pos++] = vector[izq++]

Mientras (med <= der)

temp[tmp_pos++] = vector[med++]

Repetir num_elementos
vector[der] = temp[der]
der--
FIN
Ordenación por intercalación: MergeSort

Dividir en el
centro

Ordenar
recursivamente

Intercalar las
Soluciones
Ordenación por intercalación: MergeSort

Llamada recursiva 1 ( MergeSort )

Llamada recursiva 2 ( MergeSort )

Llamada recursiva 3 ( MergeSort )

6 12 4 9 8 13 5 Volver 3 a 2 ( Combina )

4 6 9 12 5 8 13 Volver 2 a 1 ( Combina )

4 5 6 8 9 12 13 Combina
Ordenación por intercalación: MergeSort

http://www.algostructure.com/sorting/mergesort.php