Ejemplos de Recursividad

1. Planteamiento Ejercicio 1. Programar un algoritmo recursivo que calcule el factorial de un número.
   Solución:

   int factorial(int n){
   if(n==0){
   return 1; //Caso Base
   }
   else {
   return n * factorial(n-1);  //Fórmula Recursiva
   }
   }
   

   
   
2. Planteamiento Ejercicio 2: Programar un algoritmo recursivo que calcule un número de la serie fibonacci.
   Solución:

   
   int fibonaci(int n){
   if(n==1 || n==2) {
   return 1;
   }
   else{
   return fibonaci(n-1)+fibonaci(n-2);
   }
   }
   

   
   
3. Planteamiento Ejercicio 3: Programar un algoritmo recursivo que permita hacer la división por restas sucesivas. ver mas...
   Solución:

   
   int division (int a, int b) {
   if(b > a) {
   return 0;
   }
   else {
   return division(a-b, b) + 1;
   }
   }
   

   
   
4. Planteamiento Ejercicio 4: Programar un algoritmo recursivo que permita invertir un número.Ejemplo: Entrada:123 Salida:321
   Solución:

   
   int invertir (int n) {
    if (n < 10) {         //caso base
     return n;
    }
    else {
     return (n % 10) + invertir (n / 10) * 10;
    }
   }
   

5. Planteamiento Ejercicio 5: Programar un algoritmo recursivo que permita sumar los dígitos de un número.Ejemplo: Entrada:123 Resultado:6
   Solución:

   
   int sumar_dig (int n) {
   if (n == 0) {      //caso base
   return n;
   }
   else {
   return sumar_dig (n / 10) + (n % 10);
   }
   }
   

   
   
6. Planteamiento Ejercicio 6: Programar un algoritmo recursivo que permita hacer una multiplicación, utilizando el método Ruso. Para mas información: aquí.
   Solución:

   
   int mult_rusa(int A, int B) {
   if(A==1){
   return (B);
   }
   if(A%2!=0){
   return (B+mult_rusa( A/2 , B*2));
   }
   else{
   return(mult_rusa( A/2 , B*2));
   }                      
   }

   
   
7. Planteamiento Ejercicio 7: Programar un algoritmo recursivo que permita sumar los elementos de un vector.
   Solución:

   
   int suma_vec(int v [], int n) {
   if (n == 0) {
   return v [n];
   }
   else {
   return suma_vec(v, n - 1) + v [n];
   }
   } 

   
   
8. Planteamiento Ejercicio 8: Programar un algoritmo recursivo que permita multiplicar los elementos de un vector.
   Solución:

   
   int multiplicar (int vec [], int tam) {
   if (tam == 0) {
   return (vec [0]);
   }
   return (vec [tam] * multiplicar (vec, tam - 1));
   }

   
   
9. Planteamiento Ejercicio 9: Programar un algoritmo recursivo que calcule el Maximo comun divisor de dos números.
   Solución:

   
   int sacar_mcd(int a, int b) {
   if(b==0) {
       return a;
   }
   else {
       return sacar_mcd(b, a % b);
   }
   }

   
   
10. Planteamiento Ejercicio 10: Programar un algoritmo recursivo que determine si un número es positivo/negativo.
    Solución:

    
    public boolean positivo(int n){
       if(n<0) return true;
       else return negativo(n);
      }
    
      public boolean negativo(int n){
       if(n>0) return false;
       else return  positivo(n);
      }
    

11. Planteamiento Ejercicio 11: rogramar un algoritmo recursivo que determine si un número es impar utilizando recursividad cruzada.
    Solución:

    
    public boolean par(int n){
    if(n==0) {
    return true;
    }
    else {
    return impar(n-1);
    }
    }
    
    public boolean impar(int n){
    if(n==0) {
    return false;
    }
    else {
    return par(n-1);
    }
    } 

    
    
12. Planteamiento Ejercicio 12: Programar un algoritmo recursivo que permita sumar los elementos de una matriz.
    Solución:

    
     int suma (int fila, int col, int orden, int mat [] [])
      {
    if (fila == 0 && col == 0)
      return mat [0] [0];
    else
      if (col < 0)
    return suma (fila - 1, orden, orden, mat);
      else
    return mat [fila] [col] + suma (fila, col - 1, orden, mat);
      }
    

13. Planteamiento Ejercicio 13: Programar un algoritmo recursivo que muestre el numero menor de un vector.
    Solución:

    
    int menorvec (int x [], int n, int menor) {
    if (n == 0) {
    if (menor > x [n]) {
     return x [0];
    }
         else {
     return menor;
    }
    }
     else{
    if (menor > x [n]) {
     return menorvec (x, n - 1, x [n]);
    }
         else {
     return menorvec (x, n - 1, menor);
    }
    }
    }
    
    int mayorvec (int numeros [], int posicion) {
        int aux;
        if (posicion == 0) {
     return numeros [posicion];
      }
        else {
     aux = mayor (numeros, posicion - 1);
     if (numeros [posicion] > aux){
      return numeros [posicion];
     }
     else{
      return mayor (numeros, posicion - 1);
     }
         } 
    }