Blog del sitio: Tecnológico

Página: ()  1 ...  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28 ...118   ()
Imagen de JHON MARIO MURILLO CORDOBA
de JHON MARIO MURILLO CORDOBA - miércoles, 11 de junio de 2014, 14:11
Todo el mundo

RECURSIVIDAD

Es una tecnica que permite que una funcion o metodo se autollame, es una forma alternativa  a los procesos iterativos(while, for, do while).

Utilidad; cuando una solucion de un proceso iterativo  es muy compleja.

Aplicaciones; recorrido de estructuras  no lineales(arboles y grafos), formulas matematicas complejas.

TABLA COMPARATIVA
RECURSIVIDAD ITERATIVOS
  • METODOS
  • CICLOS(WHILE,DO WHILE, FOR)
  • LOGICA SIMPLE
  • PUEDE TENER LOGICA COMPLEJA
  • REDUCCION DE CODIGO
  • NO REDUCE CODIGO
  • CONSIDERABLE USO DE MEMORIA
  • BAJO CONSUMO DE MEMORIA

IMPLEMENTACION / SINTAXIS

public static tipo/clase  nombremetodo recursivo  (parametros formales){

   if(expresion logica){//control autollamado

   /////

   }nombremetodorecursivo(parametros actuales)// autollamado

}

EJEMPLO FACTORIAL

n!=n*(n-1)!

5!=5!*4  =120

4!=4!*3  =24

3!=3!*2  =6

2!=2!*1  =2

1!=1!*0  =1

0!=1

factorial

public class principal{

 public static long factorial(int n){

  if(n==0){

     return 1;

   }else{

     return n*factorial(n-1);

   }

}

public static void main (String.... args){

  System.out.print(factorial(5));

}

}

LONGITUD DE ENTERO

 public static long longitudEntero(int n){

  if(n/10==0){

     return 1;

   }else{

     return longitudEntero(n/10);

   }

 }

 

MOSTRAR INVERTIDOS

public class principal{

  public static void main (String.... args){

     int x[]  ={3,7,5,4,9};

     mostrarelementos(x,x.lengt);

  }

   public static void mostrarelementos (int v[],int n){

     if(n>0){

         System.out.println(v[n-1]);

          mostrarelementos(v[n-1]);

     }

}//MOSTRAR INVERTIDOS

 

 

MOSTRAR ELEMENTOS

public class principal{

  public static void main (String.... args){

     int x[]  ={3,7,5,4,9};

     mostrarelementos(x,x.lengt);

  }

   public static void mostrarelementos (int v[],int n){

     if(n>0){

          mostrarelementos(v[n-1]);

         System.out.println(v[n-1]);

     }

}//MOSTRAR ELEMENTOS

RECURSIVIDAD

 

ARBOLES 

Estructura no lineal para organizar informacion en forma de niveles.

Utilidad; cada vez que tengan que organizar los datos en forma jerarquica,estructuracion de datos en forma jerarquica

(distingir  entre mayores y menores).Directorio, organigrama, genealogia, ordenamiento, busqueda, evaluaciones de expresiones aritmeticas,etc.

  • altura: cantidad de niveles.
  •  Nodo raiz; es unico, sin ascendentes.
  • Nodo interno; tiene descendentes como ascendentes.
  • Nodo hoja; no tiene descendientes.
  • Subarbol; es un nodo con todos sus descendientes.
  • Peso;cantidad de hojas.
  • Orden;cantidad de nodos.
  • Rama; camino desde la raiz hasta una hoja.

arbol

 

 IMPLEMENTACION DE ARBOLES

ARBOLES3

VECTORES

EJEMPLO

NODOS

NODO

CLASIFICACION DE ARBOLES

  1. GENERAL
  2. BINARIO
  • EXPRESION
  • BUSQUEDA
  1.         ABB
  2.          AVL

ARBOLES DE EXPRESION; son los arboles binarios completos para la evaluacion de expresiones aritmeticas  en este caso, las hojas son los operandos y el resto de nodos los operadores

arboles binarios; tienen maximo dos descendientes por nodos.

SUBARBOLES

  1. COMPLETO
  2. BALANCEADO
  3. LLENO
  4. DEGENERADO

COMPLETO;todos los nodos exepto las hojas tiene hijos.

BALANCEADO; diferenciaentre altura del subarbol izquierdo y el subarbol derecho para todos los nodos no superior a 1.

LLENO; tiene el maximo de nodos en todos sus niveles 2n-1.

DEGENERADO; todos los nodos exepto las hojas tienes un hijo.

 

RECORRIDOS DE ARBOLES BINARIOS; visitar a todos los nodos para hacer las respectivas operaciones.

 

OPERACIONES DE BUSQUEDA

REGLA(INSERCION); todo nodo debe tener  descendiente con clases  menores en subarbol izquierdo y clases mayores en subarbol derecho.

REGLA(ELIMINACION);

  1. que sea un nodo hoja (se suprime).
  2. que sea un nodo con un con un subarbol, se remplaza  por su descendiente inmediato.
  3. que sea un subarbol nodo con dos subarbol, se remplaza por el nodo mas a la izquierda  del subarbol derecho  o por el nodo mas a la derecha  del sub arbol izquierdo.

ARBOLES AVL

una version mejorada de los ABB, ya que tienen un proceso de balanceo cuando el arbol tiende a degenerarse.

degenerado

Los arboles AVL son arboles binarios de busqueda balanceados, proponer un algoritmo que estructura el arbol para recuperar su balance perdido en operaciones de insercion y eliminacion.

avl 

Factor de equilibrio; la diferencia entre las alturas del subarbol izquierdo y derecho(FE).

FE=hSi-hSd.

 hSd=altura del subarbol derecho.

hSi=altura del subarbol izquierdo.

 

TIPOS DE ROTACION; comprometen tres nodos desde el nodo con FE fuera de rango de balance descendiente hasta la hoja insertada.

CASO 1 II(IZQUIERDA-IZQUIERDA)

insertar C,B,A

II

CASO 2 DD(DERECHA-DERECHA)

insertar A,B,C

DD

 CASO 3 ID(IZQUIERDA-DERECHA)

insertar C,A,B

ID

CASO 4 DI(DERECHA-IZQUIERDA)

insertar A,C,B

DI

 

 

 

 

 

 

 

 

 

[ Modificado: jueves, 12 de junio de 2014, 11:04 ]
 
Imagen de Roger De Jesus Muñoz Villalobos
de Roger De Jesus Muñoz Villalobos - miércoles, 11 de junio de 2014, 14:08
Todo el mundo
  • Arboles binarios

Tienen una restriccion maxima, maximo dos hijos por nodos.

  • Arboles completos

Todos los nodos tienen dos hijos excepto las hojas.

  • Arboles balanceados

Parfa todos los nodos, la diferencia ente las alturas del subarbol izquierdo y derecho es menor a 2

  • Arboles llenos

Todos los niveles del arbol tiene el maximo de nodos 2^h-1. 

  • Arboles degenerados

Todos los nodos tienen un solo hijo excepto las hojas.

  • Ejemplos

[ Modificado: miércoles, 11 de junio de 2014, 14:23 ]
 
Imagen de Jean Carlos Robles Atencia
de Jean Carlos Robles Atencia - miércoles, 11 de junio de 2014, 13:59
Todo el mundo

public class principla {

public static void main (String []arg){

System.out.println(factoria(5));

}

public static long factorial(int n){

if(n==0){

return 1;

}else{

return n*factorial(n - 1);

}

}

EJERCICIOS: funciones recursivas para:

* calcular potencial entre dos numeros naturales 

* mostrar elementos de un vector

*calcular maximo comun divisor de dos numeros enteros 

*mostrar los elementos de listas enlasadas simple en forma invertida

*calcular la cantidad de digitos de un numero entero 

 

public static int mcd (int a, int b ){

if(a==b){

return a ;

}else{

if (a>b){

return mcd(a-b,b);

}else{

return mcd (a,b-a);

}

}

}

 

ARBOLES:Estructura no lineal para la organización de la información por niveles

UTILIDAD: Organizacion de datos en forma jerarquica (distincion entre mayores y menores ) 

APLICACION: S.O. : directivos, evaluacion de expresion, aritmaticas, busqueda y ordenamiento, etc.

 

 

 

 

 

 

[ Modificado: miércoles, 11 de junio de 2014, 13:59 ]
 
Todo el mundo

Arbol

arreglos

nodos

Aplicaciones: subclasificacion

arboles binarios: tienen una restriccion, maxino dos hijos por nodo

aplicaciones: evaluacion de expresiones aritmeticas busqueda y ordenamiento etc.

terminologia:

arbol completo: todos los nodos tienen dos hijos excepto las hojas

arbol balanceado: para todos los nodos la diferencia entre las alturas del arbol izquierdo y derecho es menor a 2

arbol lleno: todos los niveles de arbol tienen el maximo de los nodos 2^h-1es la cantidad total de nodos del arbol

arbol degenerado: todos los nodos tienen un hijo excepto las hojas

un arbol binario se notara por un subarbol izquierdo y otro derecho, su inclinacion hacia la izquierda y derecha siempre debe diferenciarse

Ejercicio

implementacion de arbol binario

public class NodoArbolBin<T>{

private T dato;

private NodoArbolBin izq;

private NodoArbolBin der;

public NodoArbolBin(){}

public NodoArbolBin(T dato){

this.dato=dato;

izq=der=null;

}

}

public class principal {

public static void main(string []arg{

NodoArbolBin raiz;

raiz=new NodoArbolBin("a"));

raiz.setizq(newNdosArbolBin("b"));

raiz.setder(new NodoArbolBin("c"));

NodorbolBin a= raiz.getizq();

a.setizq(new NodoArbolBin("d"));

a=raiz.getder();

a.setizq(new NodoArbolBin("e"));

a.setder(new NodoArbolBIN("F"));

}

}

Recorridos: combinacion de actividades pa visitar todos los nodos y hacer las respectivas operaciones

1. visitar raiz

2. recorrer subarbol izquierdo

3. recorrer subarbol derecho

 

combinaciones          recorrido

1,  2,  3                     preorden: raiz- izq- der

2,  1,  3                     inorden: izq- raiz- der

2,  3,  1                     posorden izq- der- raiz

 

 

 
Imagen de JUAN ERASMO PEREZ ALVARADO_12217058
de JUAN ERASMO PEREZ ALVARADO_12217058 - miércoles, 11 de junio de 2014, 13:39
Todo el mundo

las colas se clasifican en colas simples que ya antes se habian visto y se ven las colas circulars 

colas circulares

estas son las operaciones de las colas circulares (con vectores)

Tamaño
•(fin-principio+max+1) mod max
Encola
• si la cola está llena lanza NoCabe
•fin=fin⊕1
• meter el elemento nuevo en la casilla fin
Desencola
• si la cola está vacía lanza NoExiste
• el elemento a retornar es el de la casilla principio
•principio=principio⊕1

 

RECURSIVIDAD

 

Es una propiedad de la funciones para ante llamarse, es una alternativa a los procesos iterativos  como por ejemplo: for, while, do-while.

 

la recursividad es util Cuando la solución de problemas es iterativamente muy complejas

algunas de las aplicaciones de la recursividad son el recorrido de estructuras no lineales (arboles) , fórmulas matemáticas complejas

Recursividad

Iteración

Métodos

for, while, do-while

Reducción de código

No reducción de Codigo

Simplicidad Lógica

Dependiendo la solución la lógica puede ser muy compleja

Consumo excesivo de memoria: por  cada auto llamado, se hace una copia de la función con variables e instrucciones

 

Bajo consumo de memoria

la recursividad es una gran alternativa para suprimir procesos repetitivos, ya que esta mismo realiza de una forma mas amigable  el llamado a su metodo o funcion que basicamente hace un autollamado del mismo metodo, al realizar recursividad hay mucho consumo de memoria lo cual conlleva mas requerimineto de memoria, lo cual puede ocasionar una paralisis en el programa 

 
Imagen de Roger De Jesus Muñoz Villalobos
de Roger De Jesus Muñoz Villalobos - miércoles, 11 de junio de 2014, 13:32
Todo el mundo
  • ¿Que Son arboles?

Son estructuras de datos no lineales para la organizacion de informacion con niveles.

  • Utilidad

Organizacion de datos de forma jerarquica (distancia entre mayores y menores)

  •  Aplicaciones

son aplicados en directorios, evaluacion de expresiones aritmeticas, busqueda y ordenamiento.

  • Terminologia. 

 

Hijo: Es aquel nodo que siempre va a tener un nodo antecesor o padre, son aquellos que se encuentran en el mismo nivel  
 
Padre: Es aquel que tiene hijos y también puede tener o no antecesores.  
 
Hermano: Dos nodos son hermanos si son apuntados por el mismo nodo, es decir si tienen el mismo padre.  
 
Raíz: Es el nodo principal de un árbol y no tiene antecesores.   
 
Hoja o terminal: Son aquellos nodos que no tienen hijos o también los nodos finales de un árbol. 
 
Interior: Se dice que un nodo es interior si no es raíz ni hoja. 

 

[ Modificado: miércoles, 11 de junio de 2014, 13:50 ]
 
Imagen de JUAN ERASMO PEREZ ALVARADO_12217058
de JUAN ERASMO PEREZ ALVARADO_12217058 - miércoles, 11 de junio de 2014, 13:24
Todo el mundo

laboratorio:

public class Pila Nodo <T> {

                       private Nodo <T> tope;

                       public PilaNodo( ) { tope=null; }

                       public boolean vacia ( )  { return tope==null; }

                       public void poner (T dato){

                                            Nodo<T> aux = new Nodo < > ( dato,tope );

                                            if(aux !=null){

                                                                    tope = aux;

                                             }else{

                                                                     System.out.println( "LA MEMORIA ESTA AGOTADA" );

                                             }

                        }

                       public T quitar ( ) {

                                           T dato=null;

                                            if (! vacia ( ) ){

                                                                      dato=tope.getDato( );

                                                                      tope=tope.getSig( );

                                            }else{

                                                                     System.out.println( "LA PILA ESTA VACIA" );

                                            }

                                            return dato;

                        }

                         public T cima ( ){

                                            T dato=null;

                                            if (! vacia ( ) ){

                                                                      dato=tope.getDato( );

                                            }else{

                                                                      System.out.println("PILA VACIA");

                                            }

                                            return dato;

                         }

}

 

Colas

reglas que resgistren las operaciones de una estructura liena FIFO (first in first out) primero en entrar primero en salir 

utilidad en colas

cuando hay demanda de recurso, el SO debe decidir que recurso atiened a que peticion

cola de proceso, cola de impresion, simulaciones....ect.

una de las utilidades en las colas son evaluaciones de operaciones aritmeticas se nos dejo unos ejercicios en los cuales habia que resolverlos

Notaciones de Evaluación:

Prefija: Operadores antes: +a*bc

Posfija: Operadores después: abc*+

Convertir de Infijo a prefijo y posfijo:

  1. a+b*c^1/2
  2. a+b*c^(1/2)
  3. (a+b)*c^(1/2)

 

Prefijo

Posfijo

1)      a+b*c^1/2

1)      a+b*c^1/2

              a+b*^c1/2

              a+b*c1^/2

              a+*b ^c1/2

              a+bc1^*/2

              a+/*b ^c12

              a+bc1^*2/

              +a/*b ^c12

              abc1^*2/+

3)      (a+b)*c^(1/2)

 

              +ab*c^(1/2)

 

              +ab*c^/12

 

              +ab*^c/12

 

              *+ab^c/12

OPERACIONES DE COLAS

poner

quitar

vacia (estados de la cola)

llena (estado de la cola)

public interface Cola <T> {

    boolean vacia();

    boolean llena();

    void poner(T dato);

    T quitar();

}

metodos  (arriba)

 

Asi como en le tema de pilas  tambien hay un codigo para las estructuras estaticas o vectores la cual seria

public class ColaVector <T> implements Cola <T>{

           private T c[ ];

           private int max, frente, fin;

          public ColaVector() {

                     max = 100;

                    frente = fin = -1;

                    c = (T[]) new Object[max];

          }

          public ColaVector(int max) {

                      this.max = max;

                      frente = fin = -1;

                     c = (T[]) new Object[max];

          }

         public boolean vacia(){return frente == -1;}

         public boolean llena(){return fin == max-1;}

         public void poner(T dato){

                     if(!llena()){

                                      if(vacia()){

                                                          frente = 0;

                                      }

                                     fin++;

                                    c[fin]=dato;

                    }else{

                             System.out.println("Cola llena..!");

                    }

           }

              public T quitar(){

                         T dato = null;

                         if(!vacia()){

                                            dato = c[frente];

                                            if(frente == fin){

                                                                      frente = fin = -1;

                                           }else{

                                                      frente++;

                                            }

                                }else{

                                         System.out.println("Cola vacia...!");

                                 }

                                 return dato;

                      }

}

 

para las estructuras  dinamicas  (listas enlazadas) el codigo seria:

public class PilaNodoDoble<T>{

                private NodoDoble<T>tope;

                 

                public PilaNodoDoble() {

                                   tope=null;

                }

                public void poner(T dato) {

                                 NodoDoble aux = new NodoDoble( null, dato, null );

                                  If( aux != null ) {

                                               If( vacia() ) {

                                                           tope = aux;

                                                } else {

                                                             tope.setSig( aux );

                                                }

                                    } else {

                                                  System.out.println( “Memoria Llena” );

                                    }

                  }

}

 
Imagen de JUAN ERASMO PEREZ ALVARADO_12217058
de JUAN ERASMO PEREZ ALVARADO_12217058 - miércoles, 11 de junio de 2014, 12:48
Todo el mundo

Definicion

 Una pila es una regla que restringe las operaciones de una estructura lineal       ( vector o lista enlazadas), este este semejante LIFO; En el proceso de inserccion y eliminacion el utimo en ser almacenado(inserccion) es el primero en se procesado(eliminacion).

 Una pila puede ser util para: recuperar datos de una actividad no temiada, retroceder en un proceso para terminar actividades no cumplidas.

 en los procesos de llamado a subprogramas en el sistema operativo es comun usar las pilas

 

OPERACIONES DE PILA ESTATICA

poner { tope++; v[tope]==dato;}

quitar{dato=v[tope];tope--;}

cima{dato=v[tope];}

vacia{tope==max-1;}

llena{tope==max-1}

 OPERACIONES EN ESTRUCTURA DINAMICA

recordemos que las estructuras Dinámica se refiere a Lista Enlazadas

Operaciones:

poner{tope=new Nodo(dato, tope);}

quitar {dato = tope.getDato();tope = tope.getSig() ;}

cima{dato = tope.getSig();}

vacia{tope==null;}

llena {aux == new Nodo (dato, tope); aux = null}

El problema de las pilas en cuanto a su implementación es su restricción.

Lo único que es posible sacar de una Pila es lo está en la cima; es decir, lo último que se puso.

Se puede utilizar cualquier estructura lineal para implementar pilas.

Utilizando la programación orientada a objetos podemos también utilizar las pilas, para mayor comprensión veremos este ejemplo:

 

Ejemplo con Vectores/Arreglos: 

public class PilaVector <T> {

                private T v[ ];

                private int max[ ];

                private int tope;

                public PilaVector( ){

                               max=100;

                                tope=-1;

                               v=( T[ ] ) new Object [ max ];

                 }

                public PilaVector(int max){

                              this.max=max;

                               tope=-1;

                               v=( T[ ] ) new Object [ max ];

                }

                public boolean vacia(  ) {return tope==-1;}

                public boolean llena(  ) {return tope == max-1;}

                public void poner( T dato ){

                              if(! llenar( ) ){

                                               tope++;

                                                v [tope]=dato;

                               }else{

                                               System.out.println("PILA LLENA");

                               }

                 }

                 public T quitar() {

                                               T dato=null;

                                               if(!vacia() ){

                                                                  dato=v[tope];

                                                                  tope--;

                                                }else{

                                                             System.out.println ("PILA VACIA");

                                                }

                                                return dato;

                     }

                     public T cima(){

                                              T dato=null;

                                               if (!vacia() ){

                                                                    dato=v[tope];

                                                                    tope max-1;

                                                }else{

                                                             System.out.println ("PILA LLENA");

                                                }

                                                return  dato;

                        }

}

para las listas enlzadas las opearaciones de pila

poner  { insertar fin(dato)}

Método para quitar:

quitar { lleva a actuar hasta ultimo modo}

Método cima: este devuelve el último dato puesto

cima { dato= L.infor();}

Método que es utilizado para validar si la lista está vacía:

vacia{ L.vacia();}

 

nota* estos metodos estan en el laboratorio pila realizado en grupo para un laboratorio

[ Modificado: miércoles, 11 de junio de 2014, 12:48 ]
 
Imagen de JUAN ERASMO PEREZ ALVARADO_12217058
de JUAN ERASMO PEREZ ALVARADO_12217058 - miércoles, 11 de junio de 2014, 12:48
Todo el mundo

Definicion

 Una pila es una regla que restringe las operaciones de una estructura lineal       ( vector o lista enlazadas), este este semejante LIFO; En el proceso de inserccion y eliminacion el utimo en ser almacenado(inserccion) es el primero en se procesado(eliminacion).

 Una pila puede ser util para: recuperar datos de una actividad no temiada, retroceder en un proceso para terminar actividades no cumplidas.

 en los procesos de llamado a subprogramas en el sistema operativo es comun usar las pilas

 

OPERACIONES DE PILA ESTATICA

poner { tope++; v[tope]==dato;}

quitar{dato=v[tope];tope--;}

cima{dato=v[tope];}

vacia{tope==max-1;}

llena{tope==max-1}

 OPERACIONES EN ESTRUCTURA DINAMICA

recordemos que las estructuras Dinámica se refiere a Lista Enlazadas

Operaciones:

poner{tope=new Nodo(dato, tope);}

quitar {dato = tope.getDato();tope = tope.getSig() ;}

cima{dato = tope.getSig();}

vacia{tope==null;}

llena {aux == new Nodo (dato, tope); aux = null}

El problema de las pilas en cuanto a su implementación es su restricción.

Lo único que es posible sacar de una Pila es lo está en la cima; es decir, lo último que se puso.

Se puede utilizar cualquier estructura lineal para implementar pilas.

Utilizando la programación orientada a objetos podemos también utilizar las pilas, para mayor comprensión veremos este ejemplo:

 

Ejemplo con Vectores/Arreglos: 

public class PilaVector <T> {

                private T v[ ];

                private int max[ ];

                private int tope;

                public PilaVector( ){

                               max=100;

                                tope=-1;

                               v=( T[ ] ) new Object [ max ];

                 }

                public PilaVector(int max){

                              this.max=max;

                               tope=-1;

                               v=( T[ ] ) new Object [ max ];

                }

                public boolean vacia(  ) {return tope==-1;}

                public boolean llena(  ) {return tope == max-1;}

                public void poner( T dato ){

                              if(! llenar( ) ){

                                               tope++;

                                                v [tope]=dato;

                               }else{

                                               System.out.println("PILA LLENA");

                               }

                 }

                 public T quitar() {

                                               T dato=null;

                                               if(!vacia() ){

                                                                  dato=v[tope];

                                                                  tope--;

                                                }else{

                                                             System.out.println ("PILA VACIA");

                                                }

                                                return dato;

                     }

                     public T cima(){

                                              T dato=null;

                                               if (!vacia() ){

                                                                    dato=v[tope];

                                                                    tope max-1;

                                                }else{

                                                             System.out.println ("PILA LLENA");

                                                }

                                                return  dato;

                        }

}

para las listas enlzadas las opearaciones de pila

poner  { insertar fin(dato)}

Método para quitar:

quitar { lleva a actuar hasta ultimo modo}

Método cima: este devuelve el último dato puesto

cima { dato= L.infor();}

Método que es utilizado para validar si la lista está vacía:

vacia{ L.vacia();}

 

nota* estos metodos estan en el laboratorio pila realizado en grupo para un laboratorio

[ Modificado: miércoles, 11 de junio de 2014, 12:48 ]
 
Imagen de Roger De Jesus Muñoz Villalobos
de Roger De Jesus Muñoz Villalobos - miércoles, 11 de junio de 2014, 12:41
Todo el mundo

 la recursividad no es una estructura de datos, es una técnica de programación que nos permite que un bloque de instrucciones se ejecute n veces. Remplaza en ocasiones a estructuras repetitivas.

Este concepto será de gran utilidad para el capítulo de la estructura de datos tipo árbol.

La recursividad es un concepto difícil de entender en principio, pero luego de analizar diferentes problemas aparecen puntos comunes.En Java los métodos pueden llamarse a sí mismos. Si dentro de un método existe la llamada a sí mismo decimos que el método es recursivo.Cuando un método se llama a sí mismo, se asigna espacio en la pila para las nuevas variables locales y parámetros.

Al volver de una llamada recursiva, se recuperan de la pila las variables locales y los parámetros antiguos y la ejecución se reanuda en el punto de la llamada al método. 

 

  • ¿Para que se utilizan?

 Para resolver procesos iterativos que tienen un alto grado de complejidad.

  • Se aplican en:

Solucion de formulas matematicas complejas y en recorridos de estructuras no lineales.

  • Ventajas:
  1. Reduccion del codigo.
  2. Logica Simple.
  3. es realizada por metodos.

 

  • Implementacion de recursividad
public static tipo // clase  *nombremetodo recursivo (parámetros) {
 
 
               // variables locales
 
       if (condición de parada) {
 
                     *instrucciones
 
      }
        
          *instrucciones
}
 
  • Ejemplo de recursividad:

Factorial 

El factorial de un número.

 como sabemos la definición matemática del factorial de un número n se obtiene de la siguiente forma:

n! = 1*2*3*.......*n ó n! = n*(n-1)*(n-2)*.....1

 

n

Llamado a factorial

4

4*factorial(3)

3

    3*factorial(2)

2

        2*factorial(1)    

1

           1*factorial(0)

0

                   1

 

Cuyo codigo Recursivo Es

public static long (int n){ 

if(n==0)

    return 1;

   else

{

return n*factorial(n-1);

    }

}

 Reflexion

Esta tecnica de programacion es muy util ya que, se reduce codigo y se pueden resolver problemas iterativos facilmente

 

 

 

 

[ Modificado: miércoles, 11 de junio de 2014, 16:48 ]
 
Página: ()  1 ...  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28 ...118   ()