Tablas Hash:
Es una especie de tabla en la que podemos insertar y sacar objetos. Cogemos un objeto de un determinado nombre, ese nombre es Hash(= resumen).
Comparamos el array con la cola y con la tabla. El tiempo para buscar algo en un array es nt/2 siendo n el número de casillas ocupadas. El tiempo de inserción en una lista y en un array es cte. En la lista creamos el objeto pero lo colocamos el primero. El tiempo que tardo en buscar a una persona en una lista es (n+1)/2 ( aunque se podría quitar el +1 porque es una cte). En la cola lo que tarda en insertar es siempre lo mismo, es cte. En la pila, es cte y >n. En la tablas hash el tiempo de búsqueda es siempre cte por eso es más efectiva, porque no depende del numero de elementos que contenga.
Los dos métodos fundamentales de estas tablas son: insertar y extraer. Tengo un array de listas enlazadas. Cada array representa una característica de lo que metes.
Recursividad:
Un método es recursivo cuando un método se llama a sí mismo. Usándola en los ejemplos de Fibonacci y factorial no es útil. No debemos usarlo porque no es práctica.
El código comentado:
public class Recursividad { // Factorial de un numero.
public long factorial(long num){
else return num * factorial(num-1);
}
public void p1(int a) // el método p1 pide un entero, si es mayor que 0 lo saca por pantalla y luego le resta 1 vuelve a comprobar si es mayor que 0, hasta que no lo es y pone “FIN”.
{
if (a>0) {
System.out.println(a);
p1(a-1);
}
else
System.out.println(“FIN”);
public void p2(int a, int b) // pide dos enteros(a,b), si el primero es mayor que 0 le resta uno al primero (a-1)y suma el segundo y el primero(b+a),si a no es mayor que 0 imprime b.
{
if (a>0) {
p2(a-1,b+a);
}
else
System.out.println(b);
}
// Método recursivo que suma los elementos de un array de enteros.
public long suma(long [] tabla, int posActual, int tamaño) // no lo entendemos muy bien, porque si la posición actual es el último elemento no sabemos como le puede sumar el siguiente.
{
// Condición de salida en el último elemento
if (posActual == tamaño -1 )
return tabla[posActual];
else
return tabla[posActual] + suma(tabla, posActual+1, tamaño);
}
// Obtener el inverso de un número dado:
// El inverso de 254 es 452
// 254 mod 10 = 4 (lo saco)
// 254 div 10 = 25
// 25 mod 10 = 5 (lo saco)
// 25 div 10 = 2
// 2 mod 10 = 2 (lo saco)
public void inverso(int n) // pide un número, lo divide entre 10, el resto es el primer número que buscamos, y el cociente lo dividimos entre 10, el resto es el segundo número y el cociente lo dividimos otra vez entre 10 hasta que el cociente sea menor que 10, que será el resto y el último número que buscamos.
{
System.out.print(n % 10);
if(n>=10)
inverso(n/10);
}
// Función de Fibonacci
// Fib(1) = 1
// Fib(2) = 1
// Fib(3) = Fib(2) + Fib (1)
// Fib(4) = Fib(3) + Fib (2)
public long fibonacci(long num) // pides un número, si es igual a 1 o igual a 2 devuelve 1, si no suma el (num-2) + (num-1).
{
if ((num == 1) || (num == 2))
return 1;
else return
fibonacci(num-2) + fibonacci(num-1);}
// Probando recursividad
public static void main(String []args){
Recursividad r =
new Recursividad();
System.out.println(“El factorial de 10 es: “+ r.factorial(10));
// Qué hace el método p1: 4,3,2,1 FIN
r.p1(4);
// ¿Cuál es el resultado de llamar a p2 así?
r.p2(3,0);
// Suma recursiva en un array
long [] tabla = {1,2,3,4,5,6,7,8,9,10};
System.out.println(“La suma de los elementos del array es: “+ r.suma(tabla, 0, tabla.length));
// Fibonacci
System.out.println(“Fibonacci de 10: “+ r.fibonacci(10));
// Inverso
System.out.print(“El inverso de 254 es: “);
r.inverso(254);
System.out.println();
}
// main
