Instituto de Computación. Facultad de Ingeniería.

Universidad de la República
Parcial de Programación 2
10 de Mayo de 2008
Generalidades:
• La prueba es individual y sin material.
• La duración es 3 horas.
• Sólo se contestan dudas acerca de la letra de los ejercicios.
• Escriba las hojas de un sólo lado y con letra clara.
• Comience la solución de cada ejercicio en una nueva hoja.
• Numere cada hoja, indicando en la primera el total.
• Coloque su número de cédula y nombre en cada hoja.
• SI TODAS LAS RESTRICCIONES EXPLICITADAS DE UN EJERCICIO NO SON CUMPLIDAS POR LA
SOLUCIÓN PROPUESTA, EL EJERCICIO TENDRÁ PUNTAJE CERO. TENER EN CUENTA LAS NOTAS
AL PIE DE CADA EJERCICIO.

Ejercicio 1 (12 puntos)

Considere la siguiente declaración, en Módula-2, del tipo de las listas de números enteros LInt:
TYPE
LInt = POINTER TO NodoLista;
NodoLista = RECORD
info : INTEGER;
sig : LInt
END;

Se pide, accediendo directamente a la representación, implementar la siguiente función iterativa:

InsOrd: Dada una lista L de enteros de tipo Lint, ordenada de mayor a menor, y dado un entero x, retorna una
nueva lista (que no comparte registros de memoria con la lista parámetro) ordenada de menor a mayor que contiene
todos los elementos de L, y además x.
Ejemplos:
Entradas Resultado de InsOrd
L = [9,9,5,2,1], x = 4 [1,2,4,5,9,9]
L = [9,5,2,1], x = 1 [1,1,2,5,9]
L = [2], x = 3 [2,3]
L = [], x = 1 [1]

NOTAS:
• La lista parámetro no debe modificarse.
• La función no debe recorrer más de una vez la lista parámetro. La lista resultado no debe recorrerse.
• No se permite usar funciones o procedimientos auxiliares.
• Las listas no deben usar celdas dummy (cabeceras).
• Pueden declararse y usarse a lo sumo dos variables auxiliares en el código de la función insOrd.

SOLUCIÓN:
PROCEDURE InsOrd (L : LNat; x : CARDINAL) : LNat;
VAR nodo, Lres : LNat;
BEGIN
Lres := NIL;
(* Copio los elementos de L mayores que a x *)
WHILE (L <> NIL) AND (L^.elem > x) DO
NEW(nodo);
nodo^.elem := L^.elem;
nodo^.sig := Lres;
Lres := nodo;
 L := L^.sig;
END;

(* Inserto x *)
NEW(nodo);
nodo^.elem := x;
nodo^.sig := Lres;
Lres := nodo;

(* Copio los elementos de L menores o iguales a x *)

WHILE (L <> NIL) DO
NEW(nodo);
nodo^.elem := L^.elem;
nodo^.sig := Lres;
Lres := nodo;
L := L^.sig;
END;

RETURN Lres;
END InsOrd;

Ejercicio 2 (12 puntos)

Considere las siguientes operaciones sobre Listas de Naturales (Cardinales):
• PROCEDURE Nula() : LN;
(* Crea la lista de naturales vacía. *)
• PROCEDURE Agregar (x : CARDINAL; VAR l : LN);
(* Inserta un elemento al principio de la lista de naturales. *)
• PROCEDURE EsNula (l : LN) : BOOLEAN;
(* Verifica si la lista de naturales está vacía. *)
• PROCEDURE Primero (l : LN) : CARDINAL;
(* Retorna el primer elemento de la lista de naturales. Precondición: la lista no es vacía.*)
• PROCEDURE Cola (VAR l : LN);
(* Elimina de la lista de naturales l su primer elemento. Precondición: la lista no es vacía.*)
Se pide: implementar una función recursiva ElimUlt, que dada una lista L de tipo LN elimine y retorne de L su
último elemento. La función debe eliminar todas las ocurrencias del último elemento. ElimUlt tiene como
precondición que L no es la lista vacía.

PROCEDURE ElimUlt (VAR L : LN) : CARDINAL;

Ejemplos:
Entrada Resultado de ElimUlt
L = [2,8,6,8,8] L = [2,6], retorna: 8
L = [6,2,3] L = [6,2] , retorna: 3
L = [2,2] L = [], retorna: 2

NOTAS:
• La función no debe recorrer la lista de manera explícita más de una.
• No se permite usar funciones o procedimientos auxiliares, aunque si pueden utilizarse las 5 operaciones
primitivas dadas sobre listas de tipo LN. De hecho, no puede asumirse una representación particular de listas de
tipo LN, la única manera de manipularlas es a través de las 5 operaciones referidas.
• No pueden definirse estructuras de datos adicionales a la lista de tipo LN.
SOLUCIÓN:

PROCEDURE ElimUlt (VAR L : LNat) : CARDINAL;

VAR prim, ult : CARDINAL;
BEGIN
prim := Primero(L);
Cola(L);
IF (EsNula(L)) THEN
ult := prim;
ELSE
ult := ElimUlt(L);
IF (prim <> ult) THEN
Agregar(prim, L);
END;
END;
RETURN ult;
END ElimUlt;

Ejercicio 3 (16 puntos: 10 parte a y 6 parte b)

Considere la siguiente declaración, en Módula-2, del tipo de los árboles binarios de búsqueda de enteros:
ABB = POINTER TO ABNode;
ABNode = RECORD
dato : INTEGER;
izq : ABB;
der : ABB;
END;
Se pide implementar las siguientes operaciones recursivamente, accediendo directamente a la representación:

a) Función BorrarMin: Dado un árbol binario de búsqueda de enteros de tipo ABB, elimina y retorna el mínimo
elemento del árbol. Precondición: el árbol es no vacío.
PROCEDURE BorrarMin (VAR A : ABB) : INTEGER;

b) Procedimiento Borrar: Dado un árbol binario de búsqueda de enteros de tipo ABB, elimina el elemento que se
encuentra en la raíz del árbol. Precondición: el árbol es no vacío.
PROCEDURE Borrar (VAR A : ABB);

NOTAS:
• En ambas operaciones el árbol resultado debe ser binario de búsqueda y tiene que liberarse la memoria de la
celda cuyo elemento sea eliminado.
• BorrarMin debe evitar recorrer nodos innecesarios del árbol.
• No pueden usarse funciones o procedimientos auxiliares, excepto para el procedimiento Borrar, que sólo
puede eventualmente usar BorrarMin.
• Borrar no debe recorrer el árbol (aunque si puede recorrerlo BorrarMin).

SOLUCIONES:
PROCEDURE BorrarMin (VAR A : ABB): CARDINAL; PROCEDURE Borrar (VAR A : ABB);
VAR aBorrar : ABB; min : CARDINAL; BEGIN
BEGIN IF (A^.der = NIL) THEN
IF (A^.izq = NIL) THEN aBorrar := A;
aBorrar := A; A := A^.izq;
min := A^.dato; DISPOSE(aBorrar);
A := A^.der; ELSE
DISPOSE(aBorrar); A^.dato := BorrarMin(A^.der);
ELSE END;
min := BorrarMin(A^.izq); END Borrar;
END;
RETURN min;
END BorrarMin;