RECURSIVIDAD

Unidad II
Introduccin
Poderosa herramienta de programacin
Alternativa a algoritmos iterativos
Solucin elegante a problemas difciles de resolver en
otro modo
Un mtodo es recursivo si contiene invocaciones a s
mismo
Condiciones que debe cumplir un
Mtodo Recursivo
Asegurar que existe una condicin de salida, en la
que no se producen llamadas recursivas (caso base).

Asegurar que se cubren todos los posibles casos
entre el base y los no base.

Cada llamada, en el caso no base, conduce a
problemas cada vez ms pequeos que terminarn
en el caso base.
Ejemplo: Factorial
Definicin recursiva:

n! = n * (n-1)! si n > 1
n! = 1 si n = 1
public class Factorial {

public int factorial ( int n ) {
if (n == 1)
return 1; //caso base
else
return n * factorial(n - 1);
}
}
import javax.swing.JOptionPane;
public class FactorialTest
{
public static void main (String[] args)
{
Factorial f;
int n, res;

n = Integer.parseInt(JOptionPane.showInputDialog
(null, "Valor de n? "));
f = new Factorial();
JOptionPane.showMessageDialog
(null, "Factorial es: " + f.factorial(n));
}

Ejemplo: fibonacci
public class Fibonacci {

public int fibo(int n) {
if (n == 0 || n == 1)
return n;
else
return fibo(n-1) + fibo(n-2);
}
}
Definicin recursiva:

Fibo(n) = Fibo(n-1) + Fibo(n-2) si n > 1
Fibo(n) = n si n = 0, 1
import javax.swing.JOptionPane;
public class FibonacciTest
{
public static void main (String[] args)
{
Fibonacci fib;
int n;

n = Integer.parseInt(JOptionPane.showInputDialog
(null, "Valor de n? "));
fib = new Fibonacci();
JOptionPane.showMessageDialog
(null, Resultado: " + fib.fibo(n));
}

Ejemplo: Multiplicacin Entera
Definicin recursiva:

a * b = a + (a * b 1) si b > 0
a * b = 0 si b = 0
public class Multiplicar{

public int multi (int a, int b) {
if (b == 0 )
return 0;
else
return a + multi(a, b-1);
}
}
import javax.swing.JOptionPane;
public class MultiplicarTest
{
public static void main (String[] args)
{
Multiplicar m;
int a, b;

a = Integer.parseInt(JOptionPane.showInputDialog
(null, "Valor de a? "));
b = Integer.parseInt(JOptionPane.showInputDialog
(null, "Valor de b? "));
m = new Multiplicar();
JOptionPane.showMessageDialog
(null, Resultado: " + m.multi(a, b));
}
}

Ejemplo: Mximo Comn Divisor
Definicin recursiva:

mcd(a, b) = mcd(a-b,b) si a >= b
mcd(a, b) = mcd(a, b-a) si b > a
mcd(a, b) = a si b = 0
mcd(a, b) = b si a = 0

Ejemplo: Invertir un nmero
public class Invertir{

public void invertir ( int n ) {
if (n < 10)
System.out.print(n);
else {
System.out.print(n % 10);
invertir(n / 10);
}
}
}
import javax.swing.JOptionPane;
public class InvertirTest
{
public static void main (String[] args)
{
Invertir inv = new Invertir();
int n;

n = Integer.parseInt(JOptionPane.showInputDialog
(null, "Valor de n? "));
inv.invertir(n);
}
}
Ejemplo: Torres de Hanoi


Estado Inicial
Primera Movida
Segunda Movida
Tercera Movida
Sptima Movida
Quinta Movida
Cuarta Movida
Sexta Movida
Ejemplo: Torres de Hanoi
public class TorresHanoi
public void hanoi (int n, String ini, String aux, String fin) {
if (n > 0) {
hanoi(n-1, ini, fin, aux);
System.out.println("Mover disco " + n + " de " + ini + " a " + fin);
hanoi(n-1, aux, ini, fin);
}
}
package aplicacion;
import java.util.*;
public class TorresHanoi {
public static void main(String[] args) {
int n;
Scanner sc=new Scanner(System.in);
System.out.print ("\nEscriba el nmero de discos en la torre de hanoi: ");
n=sc.nextInt();
while(n < 0){
System.out.print ("Error, reescriba el nmero de discos en la torre de hanoi: ");
n = sc.nextInt();
}
TorresDeHanoi tdh = new TorresDeHanoi();
tdh.hanoi(n, "Primera Torre", "Tercera Torre", "Segunda Torre");
}
}
Ejemplo: Resolver un laberinto
public class Laberinto
{
public boolean resuelve(char[][] lab, int x, int y)
{ lab[y][x] = '.';
if (x == 0 || y == 0 || x == lab[0].length - 1 ||
y == lab.length - 1) {
System.out.println("\nSolucin encontrada");
imprime(lab);
return true;
}

//Arriba
if (lab[y-1][x] == ' ') {
if (resuelve(lab, x, y-1) == true)
return true;
}

//Abajo
if (lab[y+1][x] == ' ') {
if (resuelve(lab, x, y+1) == true)
return true;
}
:::::::::
}
//Izquierda
if (lab[y][x-1] == ' ') {
if (resuelve(lab, x-1, y) == true)
return true;
}

//Derecha
if (lab[y][x+1] == ' ') {
if (resuelve(lab, x+1, y) == true)
return true;
}

//Este camino no tiene solucin
lab[y][x] = ' ';
return false;
}

public void imprime(char[][] lab) {
for (int i = 0; i < lab.length; i++) {
for (int j = 0; j < lab[i].length; j++) {
System.out.print(lab[i][j]);
}
System.out.println();
}
}
Ejemplo: Resolver un laberinto
public class LaberintoTest
{
public static void main(String[] args) {
char[][] laberinto = new char[][] {
{'#', '#', '#', '#', '#', '#'},
{'#', '.', '#', ' ', ' ', '#'},
{'#', ' ', ' ', ' ', '#', '#'},
{'#', ' ', '#', '#', '#', '#'},
{'#', ' ', ' ', ' ', '#', '#'},
{'#', ' ', '#', ' ', ' ', '#'},
{'#', '#', '#', '#', ' ', '#'} };
Laberinto Laber;
System.out.println("\nSituacin Inicial: ");
Laber = new Laberinto();
Laber.imprime(laberinto);
Laber.resuelve(laberinto, 1, 1);
}
}
Cuando utilizar Recursividad
En general, las soluciones recursivas son menos
eficientes que las iterativas (en tiempo y memoria).

Consejos:

Los algoritmos que por naturaleza son recursivos y donde la
solucin iterativa es complicada, deben resolverse por
mtodos recursivos.

Cuando haya una solucin obvia al problema por iteracin,
debe evitarse la recursividad.
Ejercicios para resolver
Elevar un nmero a una potencia no negativa n
X
n
= 1 si n = 0;
X
n
= X * X
n-1
si n > 0

Sumar los primeros n nmeros de la serie
1 + 1/2 + 1/3 + 1/4 + 1/5 +

Resolver el problema de bsqueda binaria

Resolver el problema de ordenamiento QuickSort

Resolver el problema de las 8 reinas

El Problema de las 8 Reinas: Algoritmo de BackTracking
El Problema de las 8 Reinas: Algoritmo de BackTracking
Bibliografa
[1] Drozdek, Adam. Estructura de Datos y Algoritmos en Java.
Segunda Edicin. Editorial Thomson.