UTN – FRBA – Algoritmos y Estructura de Datos – Examen Final – 07/12/2013 Apellido y nombre:__________________________________ Legajo:__________ Cursó con Prof:_______________ Cantidad de hojas entregadas:_ Nota:_______________ Evaluó Prof: ________________ • Si luego de la lectura del examen, durante la resolución tiene alguna duda, escriba hipótesis de trabajo, las cuales también serán evaluadas. • Los puntos que solicitan codificación puede ser respondidos en C, C++, o en Pascal, pero debe indicar el lenguaje utilizado. • En C y C++ prototipo refiere a la declaración de la función, es decir tipo de dato retornado, nombre de la función, y tipos de los parámetros; en Pascal el concepto prototipo es análogo al encabezado del procedimiento o de la función previa al bloque que lo define.

1. Fusión en una estructura abstracta de un archivo de registros con una lista enlazada Temas evaluados: Corte de control, fusión, apareo, listas enlazadas, abstracción procedural, archivos, y flujos. Diseñe o codifique un subprograma que fusione en una estructura abstracta el contenido de un archivo con el de una lista enlazada de listas enlazadas. Los datos a tratar son secuencias de valores del tipo carácter que se agrupan bajo valores del tipo entero. El prototipo debe ser: procedure Fusionar(n:String, l: Lista, var p: Puntero) void Fusionar(const string& n, const Lista& l, Puntero& p); Asuma que el archivo y la lista de listas están ordenados de menor a mayor. Los registros del archivo tienen el campo grupo que es un entero y campo valor que es un carácter. El primer nivel de la lista de listas, es una lista enlazada de enteros, y el segundo nivel es una lista enlazada de caracteres. Por ejemplo:

Asuma que los caracteres en los grupos de la lista están siempre en el rango [a-m] y que los que están en el archivo están en el rango [n-z]; lo que implica que primero deben agregarse los valores de la lista, y luego los del archivo. El subprograma recibe una cadena con el nombre del archivo, y debe utilizar la biblioteca adjunta para recorrer ambas secuencias. El parámetro p es de salida, los otros dos son de entrada. La estructura que contendrá la fusión del archivo con la lista enlazada se debe manipular con las siguientes operaciones. function Crear():Puntero Puntero Crear(); Crea la estructura. procedure InsertarGrupo(var p: Puntero, g:Integer) void InsertarGrupo(Puntero &p, int g); Inserta en la estructura apuntada por p un nuevo grupo con identificador g. Si la estructura ya contenía ese grupo, no lo inserta. procedure InsertarValorEnGrupo(p: Puntero, g:Integer, v:Character) void InsertarValorEnGrupo(Puntero p, int g, char v); Inserta en la estructura apuntada por p el carácter v en el grupo g; Si g ya contiene v, no lo inserta. Si p no contiene g, lo inserta junto con v.

2. Selección de estructura eficiente Temas evaluados: Estructuras de datos, abstracción de datos, y abstracción procedural. • Describa y justifique cual es la mejor estructura concreta para la estructura abstracta descripta en el punto

UTN – FRBA – Algoritmos y Estructura de Datos – Biblioteca Genérica

Para la resolución del examen, los siguientes procedimientos y funciones pueden ser invocados sin ser implementados. Por cada procedimiento o función que decida invocar debe reescribir su prototipo reemplazando correctamente las palabras subrayadas y en cursiva (llamadas variables o no terminales); la invocación debe ser precisa y concordar con el prototipo.

Operaciones sobre Archivos bool LeerEspecial(FILE* in, TipoRegistro* registro); function LeerEspecial(var archivo: TipoArchivo; var registro: TipoRegistro): Boolean Lee un registro desde archivo y almacena en registro. Retorna pudo leer ? True : False. int BuscarBinArchivo(FILE* in, Tipo valor); function BuscarBinArchivo(var archivo: TipoArchivo; valor: Tipo): Integer Busca valor en archivo, mediante el algoritmo de búsqueda binaria. Retorna lo encontró ? Posición : -1. void BuscarBinArchivo(FILE* in, TipoInfo clave, TipoRegistro* registro); procedure BuscarBinArchivo(var archivo: TipoArchivo; clave: TipoInfo; var registro: TipoRegistro) Retorna el registro que tiene la clave buscada, la que se supone existe.

Operaciones sobre Arreglos procedure OrdenarArregloPorCampo(var arreglo: TipoArreglo; n: Integer) void OrdenarArregloPorCampo(Tipo arreglo, int n); Ordena por campo los primeros n elementos de arreglo. procedure CargarSinRepetir(vararreglo: TipoArreglo;n:Integer;varpos;varinserto:Boolean;clave: TipoInfo) void CargarSinRepetir(Tipo arreglo,intn,int&n,bool&inserto, TipoInfo clave); Carga una clave sin repetición en un arreglo, retorna en Pos, el índice donde lo encontró o lo insertó, y en inserto True, en caso de haberlo insertado function BuscarBinArreglo(var arreglo: TipoArreglo; N: Integer; clave: TipoInfo): Integer int BuscarBinArreglo(Tipo arreglo, int N, TipoInfo clave); procedure BuscarBinArreglo(vararreglo: TipoArreglo;N:Integer;clave: TipoInfo;varPos:Integer) procedure BuscarBinArreglo(Tipo arreglo, int N, TipoInfo clave, int& pos); Similar a la búsqueda binaria en archivo, modificando la estructura de dato y con el agregado de N que representa el tamaño lógico del arreglo

Estructuras Enlazadas

TipoNodo = record of info: TipoInfo; siguiente: ^TipoNodo;end;TipoPuntero =struct ^TipoNodo; TipoNodo { TipoInfo info; TipoNodo* siguiente;};typed Nodo info

Operaciones sobre Pilas procedure Push(var pila: TipoPuntero; valor: TipoInfo) void Push(TipoPuntero& pila, TipoInfo valor); Agrega valor a la cima de pila. procedure Pop(var pila: TipoPuntero; var valor: TipoInfo) void Pop(TipoPuntero& pila, TipoInfo& valor); Saca la cima de pila y la almacena en valor. function EstaVacia(frente, fin: TipoPuntero): Boolean bool EstaVacia(TipoPuntero& pila); Retorna True si la pila está vacía, si no, False.

siguiente

UTN – FRBA – Algoritmos y Estructura de Datos – Biblioteca Genérica Operaciones sobre Colas procedure Agregar(var frente, fin: TipoPuntero; valor: TipoInfo) void Agregar(TipoPuntero& frente, TipoPuntero& fin, TipoInfo valor); Agrega valor al final de una cola. procedure Suprimir(var frente, fin: TipoPuntero; var valor: TipoInfo) void Suprimir(TipoPuntero& frente, TipoPuntero& fin, TipoInfo& valor); Saca del primer elemento una cola y lo almacena en valor. function EstaVacia(frente, fin: TipoPuntero): Boolean bool EstaVacia(TipoPuntero& frente, TipoPuntero& fin); Retorna True si la cola está vacía, si no, False.

Operaciones sobre Listas procedure InsertarNodo(var lista: TipoPuntero; valor: TipoInfo) void InsertarNodo(TipoPuntero& lista, TipoInfo valor); procedure InsertarNodoDec(var lista: TipoPuntero; valor: TipoInfo) void InsertarNodoDec(TipoPuntero& lista, TipoInfo valor); Inserta en una lista ordenada en forma creciente (decreciente) por el primer campo valor. procedure SuprimirNodo(var lista: TipoPuntero; valor: TipoInfo) void SuprimirNodo(TipoPuntero& lista, TipoInfo valor); Busca un nodo con las características de valor, si lo encuentra lo elimina procedure BuscarOInsertar(var lista, ptr: TipoPuntero; valor: TipoInfo) void BuscarOInsertar(TipoPuntero& lista, TipoPuntero& ptr, TipoInfo valor); Busca un nodo con los datos de valor, si no lo encuentra, lo inserta y retorna en ptr la dirección de memoria creada. Si estaba retorna en ptr esa dirección. procedure InsertarPrimero(var lista: TipoPuntero; valor: TipoInfo) void InsertarPrimero(TipoPuntero& lista, TipoInfo valor); procedure InsertarAntesDe(var lista: TipoPuntero; valor: TipoInfo) void InsertarAntesDe(TipoPuntero& lista, TipoInfo valor); procedure InsertarDespuesDe(var lista: TipoPuntero; valor: TipoInfo) void InsertarDespuesDe(TipoPuntero& lista, TipoInfo valor); procedure InsertarAlFinal(var lista: TipoPuntero; valor: TipoInfo) void InsertarAlFinal(TipoPuntero& lista, TipoInfo valor); Cada procedimiento crea un nodo con valor y lo enlazan relativo a lista en la posición indicada por su nombre. function BuscarPorCampo(lista: TipoPuntero; valor: Tipo): TipoPuntero TipoPuntero BuscarPorCampo(TipoPuntero lista, TipoInfo valor); Busca el primer nodo con campo igual a valor. Retorna lo encontró ? Puntero al nodo : punteronulo