ESTRUCTURAS DE DATOS

UNIDAD UNO - SEMANA DOS

EJERCICIOS PROPUESTOS *

1. PAVIMENTACIÓN

1.1. Halle una función recursiva que entregue como resultado el número de maneras de
pavimentar un camino de dimensiones utilizando baldosas de tamaño que se
pueden ubicar horizontal o verticalmente. Por ejemplo, para hay ocho maneras de
pavimentar un camino de dimensiones utilizando baldosas de tamaño , para
hay cinco maneras, para hay tres maneras, para hay dos maneras, para
hay una manera, y para hay una manera (no colocar ninguna baldosa).

Camino

Opciones
Opción 1: Opción 2: Opción 3:

Opción 4: Opción 5: Opción 6:

Opción 7: Opción 8:

1.2. Implemente en Java la función diseñada en el numeral anterior.

2. MÁXIMO COMÚN DIVISOR

2.1. Investigue sobre el algoritmo de Euclides, que calcula recursivamente el máximo común
divisor entre dos números, e implemente una función
public static int gcd(int a, int b) {
//...
}

*
Resumen del libro Estructuras de Datos en Java de Alejandro Sotelo Arévalo, cuya publicación está pendiente.

ESTRUCTURAS DE DATOS 1
que cumpla tal fin.

2.2. Adapte la solución del numeral anterior para que funcione sobre números de tipo
BigInteger, implementando el método
public static BigInteger gcd(BigInteger a, BigInteger b) {
//...
}
Su solución debe ser recursiva. ¡No haga trampa usando la función gcd de la clase
BigInteger!

2.3. Aplique la técnica de Memoization sobre la función implementada. Siga el esquema:

public static BigInteger[][] tabla=new BigInteger[101][101];
public static BigInteger gcdMemoization(BigInteger a, BigInteger b) {
//...
}

3. ALGORITMO DE ORDENAMIENTO RÁPIDO (QUICK SORT)

3.1. Investigue sobre el algoritmo de Ordenamiento Rápido (Quick Sort). Describa el

algoritmo con sus propias palabras, en pseudocódigo.

3.2. ¿El algoritmo Quick Sort usa la técnica de Dividir y Vencer? ¿Por qué?

3.3. Invéntese un arreglo de números enteros de tamaño 8 y explique paso a paso en sus
propias palabras cómo el algoritmo Quick Sort ordena el arreglo.

3.4. ¿Por qué la complejidad temporal del algoritmo en el caso promedio es de

?

3.5. ¿Por qué la complejidad temporal del algoritmo en el peor caso es de ? ¿En qué
consiste el peor caso? ¿Qué tan frecuentemente ocurre?

3.6. Implemente el algoritmo en Java por sus propios medios.

4. STOOGE SORT

El algoritmo de Ordenamiento Chiflado (Stooge Sort) ordena un arreglo de la siguiente

manera:

1. Si el último elemento del arreglo es menor que el primero, intercambia tales elementos.
2. Si hay tres o más elementos en el arreglo:
2.1. Ordena recursivamente los primeros dos tercios del arreglo.
2.2. Ordena recursivamente los últimos dos tercios del arreglo.

ESTRUCTURAS DE DATOS 2
2.3. Ordena (de nuevo) recursivamente los primeros dos tercios del arreglo.

Implementado en Java:
public static void stoogeSort(long[] pArreglo, int pInf, int pSup) {
// Si hay uno o cero elementos en el arreglo:
if (pSup<=pInf) {
// No hacer ninguna operación
}
// Si hay dos o más elementos en el arreglo:
else {
long primero=pArreglo[pInf],ultimo=pArreglo[pSup];
// Si pArreglo[pSup] es menor que pArreglo[pInf]:
if (ultimo<primero) {
// Intercambiar el primero con el último:
pArreglo[pInf]=ultimo;
pArreglo[pSup]=primero;
}
// Si hay tres o más elementos en el arreglo:
if (pSup-pInf+1>=3) {
int t=(pSup-pInf+1)/3;
// Ordenar recursivamente los primeros 2/3:
stoogeSort(pArreglo,pInf,pSup-t);
// Ordenar recursivamente los últimos 2/3:
stoogeSort(pArreglo,pInf+t,pSup);
// Ordenar recursivamente (de nuevo) los primeros 2/3
stoogeSort(pArreglo,pInf,pSup-t);
}
}
}

4.1. ¿Por qué el algoritmo usa la técnica de Dividir y Vencer?

4.2. Demuestre detalladamente que el algoritmo tiene complejidad temporal ,

que es aproximadamente . Ayuda: puede usar la fórmula de cambio de base
, la fórmula y la ecuación .

5. MEMOIZATION EN DOS DIMENSIONES

5.1. Sea una función que recibe como parámetro dos números naturales y tales
que , y que está definida de la siguiente manera:

5.2. Construya una tabla de tamaño que muestre los resultados de para todos
los valores de y que estén entre y .

5.3. Implemente en Java un procedimiento recursivo (sin usar Memoization) que calcule
. Utilice la clase BigInteger para los cálculos y siga el siguiente esquema:
public static BigInteger gRecursivo(int n, int k) {
// ...

ESTRUCTURAS DE DATOS 3
 }

5.4. Halle una ecuación de recurrencia que describa la complejidad temporal del algoritmo
codificado en el numeral anterior considerando como operaciones básicas las sumas, las
restas, las multiplicaciones y las comparaciones. Explique detalladamente cómo determinó la
fórmula, pero no encuentre una fórmula cerrada para la recurrencia.

5.5. ¿Valdría la pena aplicar la técnica de Memoization? ¿Por qué?

5.6. Sin importar la respuesta a la pregunta anterior, implemente en Java un procedimiento

recursivo que calcule con la técnica de Memoization, almacenando los resultados en
una matriz de números (de tipo BigInteger) con filas y columnas, siguiendo el
siguiente esquema:
public static BigInteger tabla[][]=new BigInteger[100][100];
public static BigInteger cMemoization(int n, int k) {
// ...
}

5.7. Calcule el valor de con los programas que implementó (el recursivo sin
Memoization y el recursivo con Memoization). Indique cuántos milisegundos demoró la
ejecución de cada uno de los dos programas para calcular la respuesta. Tenga en
consideración que la ejecución podría tardar más de un minuto.

5.8. ¿Cuál versión del algoritmo se demoró menos ejecutando las pruebas? Justifique
plenamente por qué el algoritmo que se demoró menos es más eficiente.

ESTRUCTURAS DE DATOS 4