1. Fusión en una estructura abstracta de un archivo de registros con

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