1.

(15 Pts) Responda en breve justificando sus respuestas (use además algún esquema/dibujo si lo
estima necesario):
(a) ¿Es verdad que un árbol binario, balanceado y completo, de n elementos, tiene un total de
2n + 1 niveles?

(b) Para un número de n = 10 nodos, dibuje la mejor y la peor forma que puede tener un árbol
binario de búsqueda.

(c) ¿Por qué en una implementación de cola mediante una lista circular simplemente enlazada,
es mejor mantener un puntero al último nodo en lugar del primero?

(d) ¿Por qué en el peor caso, el tiempo promedio de búsqueda de un elemento en una Tabla
HASH no es constante?

(e) ¿Por qué una lista enlazada no es más eficiente que un arreglo para la búsqueda de datos?
2. (9 Pts) Para el apartado de código mostrado en el siguiente cuadrado, indique en el espacio previsto
2 valores para el parámetro num de los cuales uno resultará al MEJOR caso y el otro al PEOR caso
de tiempo de ejecución de la función fnc(‧) y JUSTIFIQUE su respuesta.

int A[ ] = {7,5,9,1,3,0,6,8,2,4};
…
int fnc (int num){ (2) MEJOR caso  num = ______
for (int i=0; i < 10; i++){ (2) PEOR caso  num = ______
if (A[i] == num) return i;
} (5) ¿Por qué?
return -1;
}
…
int i = fnc ( ??? );
3. (60 Pts) Asumiendo que el atributo p de un nodo x (i.e. x.p) en el pseudo-código apunta al nodo
padre de x:

Tree-Function (x)
1 if x.right ≠ NIL
2 return Tree-Minimum (x.right)
3 y = x.p
4 while y ≠ NIL and x == y.right
5 x = y
6 y = y.p
7 return y

(a) (3) ¿Cuál es la profundidad de este árbol?

(b) (7) Responda en breve ¿qué es lo que retorna la función Tree-Function(‧) ejecutada sobre el
nodo con no. 10 y el nodo con no. 40 de este árbol binario de búsqueda? ¿Existe alguna relación
particular entre el nodo x y el nodo y que ella retorna? (La Tree-Minimum(‧) retorna el valor mínimo
del subárbol que se le pasa como parámetro)

(c) (17) Escriba un código C que utilice la siguiente función insert(‧) para agregar correctamente los
nodos y crear el árbol binario de búsqueda tal como se muestra en la figura:
void insert (int, struct node**)

(d) (17) ¿Indique en qué orden específicamente se imprimirían los datos del árbol si lo recorremos en
POST orden?

(e) (8) Escriba una función “recursiva” que imprime los datos de un árbol binario de
búsqueda de MAYOR a MENOR.

(f) (8) Si tuvieras un arreglo de n elementos en orden ascendente, describe brevemente una
estrategia para recorrer el arreglo y crear, a partir de estos datos, un árbol binario de búsqueda
BALANCEADO. Dibuja un ejemplo para 10 nodos y explique su algoritmo.
4. (8 Pts) Suponga que se tienen 3 stacks, s1, s2 y s3 con las configuraciones iniciales como se
muestra a la izquierda (inicio), y la condición final que se muestra a la derecha (fin). Indique la
secuencia de operaciones push() y pop() que debe ejecutarse de manera de obtener la configuración
final en s3. Por ejemplo, para sacar un elemento del stack s1 y colocarlo en el stack s3, utilice la
notación: s3.push(s1.pop())

inicio fin
A C
B A
C D
D B
--- --- --- --- --- ---
s1 s2 s3 s1 s2 s3
5. (8 Pts) Dados los siguientes valores de claves {2341, 21, 148, 2839, 3920, 428}, una Tabla HASH
de m=7 slots y la siguiente función HASH h´(x) = x mod m, dibuje el contenido de la Tabla HASH
luego de insertar estos mismos valores en el orden dado (procesados de izquierda a derecha),
resolviendo colisiones mediante "open addressing" utilizando linear probing para calcular la
secuencia de prueba.
BONUS (5 Pts) Dadas las siguientes funciones de la interfaz de STACK que desarrollamos:

int push(Stack* st, int item);

// @brief : realiza "pop() + pop()" y hace push() el resultado
int pushSumOf2Pops (Stack* st);
// @brief : realiza "pop() - pop()" y hace push() el resultado
int pushSubOf2Pops (Stack* st);
// @brief : realiza "pop() * pop()" y hace push() el resultado
int pushMulOf2Pops (Stack* st);
// @brief : realiza "pop() / pop()" y hace push() el resultado
int pushDivOf2Pops (Stack* st);

completen el siguiente código utilizando dichas funciones para calcular la siguiente fórmula:

[(256 / 8) * 4 + 128] - 64

int main(){

/*Generar 1 stack de capacidad 20*/

Stack* stack1 = getNewStack(20);

.
.
.