Ejercicios

• Factorial

public class factorial {
private static inout io = new inout();
public static void main (String args[]) throws Exception
{
int a,m,p;a=io.readint();m=factorialrec(a);p=factorial2(a);io.writeln(m);io.writeln(p);
}
public static int factorialrec(int x)
{
int aux;aux=1;if (x==0)aux=1;else aux=aux*factorialrec(x-1);return aux;
}
public static int factorial2(int x)
{
int i,f;i=0;f=1;while (i != x)
{
i=i+1;f=f*i;}
return f;
}
}

• Fibonacci

public class Fibonacci {

public static long fib(int n)

{

if (n <= 1) return n;

else

return fib(n-1) + fib(n-2);

}

public static void main(String[] args) {

int N = Integer.parseInt(args[0]);

for (int i = 1; i <= N; i++)

System.out.println(i + ": " + fib(i));

}

}

• Algoritmo Recursivo Torres de Honoi

Hanoi (dim N , palo A, palo B , palo C)

// N, origen, destino , auxiliar

Si N == 1

Imprimir : Pasar disco de A a B

else

Hanoi(N-1 , A , C, B)

Imprimir : Pasar disco de A a B

Hanoi(N-1 , C , B , A)

Defeniciones Basicas

• Dato: Unidad mínima de información. En programación, es la expresión general que describe las características de las entidades sobre las cuales opera un algoritmo.
• Dato Abstracto (TDA/TAD/ADT): Defino un objeto, propiedad, operación y omito características del objeto como tal
• Encapsulamiento: Oculta informaión.
• Recursividad: Es una técnica de programación (puedo invocar una función).
• Recursividad Directa: Procedimiento, hay una llamada a la misma función.
• Recursividad Indirecta: Procedimiento que invoca otro procedimiento para llamar a una función.
• Recursividad Cola: Última instrucción que ejecuta el procedimiento.
• Algoritmo: Es un conjunto de instrucciones bien definidas, ordenadas y finitas de operaciones que permite hallar la solución a un problema. Dado un estado inicial y una entrada, a través de pasos sucesivos y bien definidos se llega a un estado final, obteniendo una solución.
• Pila: Se intoducen o se quitan elementos por el mismo extremo.
• Lifo: Ultimas en entrar, primeras en salir.
• Fifo: Primeras en entrar, pimeras en salir.

Estructuras Lineales

1. Lista: Conjunto de elementos llamados nodos.
2. Arreglos: Estáticos, tienen un tamaño definido.
3. Elementos Enlazados: Dinámicos, tamaño indiferente.

• Operaciones: insertar, borrado, buscar, recorrer, vacio, tamaño.
• public void insertar ( String Elemento);
• public boolean eliminar (String elemento);
• public String eliminar ();
• public boolean busacr (String elemento);
• public String recorrer ();
• public boolean vacio ();
• puiblic int tamaño ();

1. Listas Enlazadas:

• Eliminar:

1. removeFirst: elimina el primer elemento de la lista.
2. removeLast: elimina el último elemento de la lista.
3. remove: elimina un elemento concreto de la lista.

• Buscar:

1. First: examina primer elemento de la lista.
2. Last: examina el último elemento de la lista.
3. Contains: determina si la lista tiene un elemento en particular.

isEmpty: determina si la lista esta vacia.

Size: determina en número de elementos en la lista.

1. Pila: Se introducen o se quitan elementos por el mismo extremo.

• Operaciones: push, pop, peek, IsEmpty, IsFull, Size.
• Push: añadir a un elemento a la pila (apilar).
• Pop: Quitar un elemento a la pila (desapilar).
• Peek: Se mira el tope de la pila.
• IsEmpty: (Esta vacia) determinar que la pila no tiene elementos.
• IsFull: (Esta llena) determinar si la pila esta llena.
• Size: Determinar el número de elementos de la pila.