TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN

Algoritmos y Estructuras de Datos I-Unidad I -1

U.I
Introducción
Cuando estudiamos la creación de programas mediante el uso de algoritmos y estructuras de
datos simples básicas (variables, arreglos, etc.), es importante recordar que dichos programas
se ejecutan, y residen en memoria durante el período de tiempo que dure su ejecución.

Si se cortara la luz, las estructuras de datos que nuestro programa usase, desaparecerían al ser
la memoria un lugar de almacenamiento volátil.

Allí es cuando aparecen los archivos, los cuales se alojan en disco, siendo estas las únicas
estructuras de datos que persisten frente a un apagado y encendido de la computadora. Por
ende, serán los archivos las estructuras que utilizaremos en caso de que queramos que la
información quede guardada para su posterior uso luego de apagada la máquina (no se perderá
la información), como así también, por ejemplo, si deseamos mudar la información de una
computadora a otra.

¿Qué es un Archivo?
Un archivo es una estructura de datos que:

 Se aloja en disco (su contenido se guarda en un dispositivo de almacenamiento

secundario, y no desaparece con la ausencia de corriente eléctrica).

 Los datos que se almacenan en un archivo se guardan en unidades llamadas registros.

 Los registros de un archivo tendrán todos la misma estructura, la cual deberá ser
claramente definida.

 A la forma con la que se guardan y se acceden físicamente a los registros, se lo llama

organización de registros, y se estudiarán 3 tipos distintos:

o Organización Secuencial

o Organización Indexada

o Organización Secuencial Indexada

Conceptos Importantes

 Asumiremos como precondición de la materia (excepto si se aclarase lo contrario), que

por defecto los archivos son de un tamaño tal que no es posible copiar todos sus
registros a memoria (por ejemplo, a un arreglo) para procesar desde allí la
información. Además, no será común aclarar el tamaño máximo de registros que poseerá
un archivo, con lo cual la idea de cargar todo un archivo en un arreglo queda aún más
relegada, puesto que no es posible establecer la dimensión fija máxima que puede llegar
a tener dicho arreglo.

4
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -1

U.I
 En relación al punto anterior, cuando trabajemos con archivos, por ejemplo, recorriendo
y leyendo el contenido de los mismos, lo que haremos será leer un registro del archivo
a la vez, para llevarlo a memoria y desde allí trabajar con nuestro algoritmo, para luego
ir y buscar otro registro y traerlo a memoria, y así sucesivamente hasta que finalicemos.
De esta forma, trabajaremos con el archivo sin necesidad de tener que mover todo el
contenido del mismo a memoria, el cual entendemos de antemano que es demasiado
grande como para llevar a cabo tal operación.

 Consideraremos que los archivos no pueden ser recorridos más de una vez para
resolver un problema. Sea lo que sea que haya que hacer, los archivos involucrados
deberán ser recorridos una sola vez, es decir, no podrán ser abiertos y cerrados
múltiples veces para volver a comenzar a recorrerlos desde el comienzo. Toda la
resolución del problema deberá llevarse a cabo con una sola pasada por la totalidad de
sus registros.

 A la hora de trabajar con un archivo, deberemos establecer su forma de apertura, la

cual condicionará la modalidad en la que podremos trabajar con el mismo, y en
consecuencia qué operadores se pueden usar luego a lo largo del desarrollo del
correspondiente algoritmo para un ejercicio dado. A los fines de nuestro pseudocódigo,
y nuestro marco común de referencia dentro de la materia, iremos estableciendo ciertos
criterios que adoptaremos como los correctos para desarrollar los ejercicios.

 A la hora de trabajar con nuestro pseudocódigo, consideraremos a los archivos con

elementos de acceso global, por lo que no serán pasados como parámetros por valor ni
referencia en las distintas rutinas con las que se opere con ellos.

Definiciones
 Un archivo abierto en modo entrada es de solo lectura

 Un archivo abierto en modo salida es de solo escritura

 Un archivo abierto en modo entrada/salida permite realizar tanto lecturas como

escrituras por igual

 Un archivo de movimientos/novedades es un archivo cuyos registros recorreremos

para lograr un objetivo, como por ejemplo modificar/actualizar los contenidos de otro
archivo y generar un informe/reporte final.

 Un archivo maestro es un archivo de referencia en el cual se almacena información útil

permanente, mediante operaciones de:

 Alta
 Baja
 Modificación

5
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -1

U.I
Operaciones
En términos generales, todas las organizaciones de archivos nos permitirán operaciones tales
como creación, apertura, lectura y grabación en el archivo, sumado a la posibilidad de poder
detectar cuándo se ha llegado al final de este, y en algunos casos brindando operaciones
específicas que no todas las organizaciones poseerán cuyo funcionamiento dependerá también
del tipo de archivo en cuestión (por ejemplo: formas de búsqueda).

Las operaciones no siempre serán las mismas para trabajar con un archivo secuencial, indexado
o secuencial indexado. Por ende, será necesario analizar los procesos de Alta, Baja o
Modificación (ABM) para cada organización de archivos llegado el momento.

Será común que, para resolver un problema, busquemos recuperar información de los archivos,
y realizar algunas consultas (trabajar con algunos registros del archivo), o generar reportes
(procesar todo el archivo). También será habitual que se nos solicite actualizar los datos
almacenados en un archivo maestro en base a la información contenida en otra fuente de datos,
como puede ser por ejemplo otro archivo, al que llamaremos archivo de novedades.

En las siguientes lecciones, estudiaremos las distintas organizaciones de registros, con sus
correspondientes algoritmos asociados, para realizar operaciones de recorrido, alta, baja y
modificación.

6
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -2

U.I
Introducción
La primera organización de archivos que vamos a estudiar es la Secuencial.

En esta organización, los registros se encuentran grabados en disco de forma consecutiva,

uno a continuación del otro. Además, el acceso y recorrido de los registros que componen al
archivo también debe realizarse de esta forma. Por ejemplo: si quisiéramos acceder al registro
N° 20 del archivo, es necesario recorrer todos los registros desde el comienzo del mismo
hasta el registro N°20. Es decir, no es posible saltearse los primeros 19 elementos para acceder
al N°20 que nos interesa, sino que estamos obligados a pasar por todos los registros anteriores
de forma consecutiva.

En este sentido, no es una organización eficiente si nuestro objetivo era acceder a un cierto
registro en concreto, aunque veremos que es la más simple para trabajar.

Sin embargo, si dentro de un archivo secuencial sabemos que se almacenan, por ejemplo, todas
las ventas de una sucursal de una empresa, y se nos solicita procesar dicho archivo para generar
un informe o reporte con cuestiones tales como cantidad total de ventas o montos totales
facturados, entonces esta organización sí es útil para dicho propósito, porque al fin y al cabo
necesitamos leer todos los registros de este archivo de comienzo a fin. Por tal motivo, nos
encontraremos con que será habitual ver que los archivos de novedades con los que
trabajaremos serán de tipo secuencial.

Formas de apertura
Es importante destacar que, en esta organización de registros, un archivo secuencial será de
entrada (E) o bien de salida (S), pero no los dos a la vez.

Entonces, si dado un archivo de novedades que contiene todas las ventas del día de una empresa,
se solicita imprimir por pantalla la suma total facturada, dicho archivo deberá ser abierto en
modo entrada (lectura), porque nos restringiremos a exclusivamente leer los registros que el
mismo contiene hasta el final.

Ahora, si tenemos un archivo secuencial que ya existe, y queremos abrirlo en modo de salida
(escritura), tenemos que tener en cuenta que todo registro que queramos guardar en dicho
archivo, se terminará ubicando a continuación del último registro del mismo, puesto que así se
comporta esta organización.

Por otro lado, si se pide crear un archivo nuevo en donde se guarden aquellas ventas cuyos
montos de facturación se encuentren por debajo de, por ejemplo, AR$ 1.000, el nuevo archivo
será creado (será de escritura por defecto) y deberemos realizar grabaciones en el mismo,
sin poder leer del archivo.

Sin embargo, no es posible para esta organización combinar la lectura y la escritura a la

vez. Así, actualizar un archivo secuencial, implica directamente crear un archivo nuevo.

3
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -2

U.I
Operaciones
Para el análisis de las operaciones, identificaremos como arch como al archivo secuencial, y a
reg como el nombre de un registro, que será del mismo tipo que los registros que componen a
arch.

Operaciones para Archivos Secuenciales

Operación Precondición Poscondición

- Prepara a arch para trabajar con él

abrir(arch), {E, S}, Secuencial
- Si se abre en modo E (entrada), se
prepara al archivo para que
comience el proceso de lectura.
- - Si se abre en modo S (salida), un
nuevo registro será grabado a
continuación del último registro que
posea arch.
- Se aclara que es Secuencial.

- Crea un archivo nuevo, llamado

arch, y lo prepara para que se
crear(arch) - graben futuros registros en él.
- Lo prepara por defecto para
trabajar con él en modo de salida.

leer(arch, reg) abrir(arch), E Transfiere a memoria el próximo

registro en disco, guardándolo en
reg.

Devuelve verdadero si se llegó al fin

fin (arch) abrir(arch, reg), E del archivo arch, y FALSO en caso
contrario.

cerrar (arch) abrir(arch, reg), {E, S} Cierra el archivo, eliminando el

acceso que existía antes.

grabar(arch, reg) abrir(arch, reg), S Graba reg a continuación del último

o registro que posea arch.
crear(arch)

4
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -2

U.I
Esquema genérico de recorrido y trabajo
A la hora de resolver problemas que involucren trabajar con archivos secuenciales, podremos
conceptualmente separar el mismo en tres fases:

 Inicialización: se crean/abren los archivos involucrados en la resolución del problema,

y se realiza la primera lectura de registro.

 Tratamiento de Registro: mientras no se trate del fin del archivo, iremos leyendo cada
registro trayéndolo a memoria, en donde será procesado para ir calculando y/o creando
el resultado final que se espera del algoritmo.

 Cierre/Informe: se cierran todos los archivos que fueron creados o abiertos, y se

informa el resultado final del algoritmo. Si el mismo constó de recorrer un archivo
secuencial ya existente, informará lo que se pedía luego de procesar todos los registros.
Caso contrario, el algoritmo habrá finalizado con la creación del archivo final que se
esperaba.

Ejemplo
Enunciado
Se tiene un archivo de registros enteros positivos. Generar otro archivo conteniendo los
registros enteros pares.

INICIO
VARIABLES: archE, archS: archivo de enteros
regN: entero
// fase de inicialización
crear(archS) // archS es archivo de salida, por ende, solo escritura
abrir(archE), E, Secuencial // archE es archivo de entrada, por ende, solo lectura
leer(archE, regN) // primer registro de archE se trae a memoria en regN
Mientras NO fin(archE) hacer // fase de tratamiento de registro
Si esPar(regN) entonces
grabar(archS, regN)
fSi
leer(archE, regN)
fMientras
cerrar(archE) // fase de cierre/informe
cerrar(archS)
FIN

Func esPar(val num: entero): lógico

esPar ← num RESTO 2 = 0
/* esPar devuelve el resultado de la expresión num RESTO 2 = 0
si num RESTO 2 = 0 es verdadero, esPar devuelve verdadero
si num RESTO 2 = 0 es falso, es Par devuelve falso */
fFunc

5
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -3

U.I
Introducción
Vamos a estudiar cómo abordar distintos tipos de situaciones en las cuales nos dicen que
poseemos uno o varios archivos secuenciales, y en donde contamos con distinto tipo de
información sobre las circunstancias dadas. En estos casos, nos informan cosas tales como el
valor máximo de elementos que pueden existir para cierto campo de los registros que guarda
un archivo, o que disponemos de un archivo de referencia (archivo maestro) el cual debemos
consultar para validar los datos que leamos de un archivo de novedades.

En estas situaciones, como nos informarán los valores máximos que ciertos campos poseerán,
podremos utilizar arreglos estáticos de dimensión fija en donde cargaremos esta información, y
podremos trabajar con ellos en forma auxiliar para construir la solución final al problema. Nos
referiremos a estas estructuras también como tablas sobre las que trabajaremos de distinta
manera dependiendo de las circunstancias.

Casos de Tablas

Caso I (Direccionamiento Directo)

Contamos con información que siempre se comporta como índice, por ejemplo: los meses que
posee un año (siempre irán de 1 a 12), o los códigos de las sucursales de una empresa que
siempre son enteros de entre 1 y un cierto MAX valor. Entonces, podemos usar ese rango de
valores como los índices de un arreglo el cual se recorrerá para resolver el problema planteado.

Esto conlleva que el direccionamiento directo sea muy eficiente para realizar búsquedas veloces,
ya que si en un arreglo A de 12 posiciones guardamos la facturación de una empresa para cada
mes del año, entonces encontrar la facturación del mes 5 (Mayo), se reduce a evaluar el arreglo
A en la posición 5, es decir A[5], lo cual sucede de forma inmediata (es decir, no es necesario
emplear estructuras de control iterativas con condicionales e iteraciones de ningún tipo).
La limitación de esta estrategia se halla en que, para funcionar como índice, tenemos que hablar
de valores de tipo entero positivo y de rango acotado. Por ejemplo, no sería posible hacer la
evaluación A[345,87] (no es de tipo entero positivo, sino real) o A[10000000] (es un entero
demasiado grande)o A["soy una cadena"] (no es de tipo entero positivo).

Supongamos que nos dicen que tenemos un archivo de Ventas (archV), en donde sus registros
están constituidos de la siguiente manera:

Reg-Ventas = registro
* Sucursal: entero // máximo de sucursales = 40
* Cliente
* Monto
* Fecha
fRegistro

3
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -3

U.I
Nuestro objetivo es recorrer el archivo de Ventas y que nuestro algoritmo finalice mostrando
por pantalla el siguiente informe:

RESUMEN DE VENTAS
Sucursal Cantidad de Ventas Monto Acumulado
1 20 10000
2 125 500000
... ... ...

Como nos informan que las sucursales están codificadas como enteros positivos, y que la
cantidad de sucursales puede ser como máximo 40 (es decir, pueden ir de 1 a 40), entonces
podemos crear un arreglo de registros de MAX = 40 posiciones, e ir contando la cantidad de
ventas e ir acumulando los montos totales por cada sucursal en dicho arreglo de registros, en
donde utilizaremos los valores de 1 a 40 como índices de nuestro arreglo. Así, podremos
identificar, por ejemplo, en la posición 7, la cantidad de ventas y el monto total para la sucursal
número 7 haciendo A[7].cant o A[7].total, respectivamente (y de la misma forma para el resto
de los valores que vayan de 1 a 40). Cuando leamos una venta (es decir, un registro) para la
sucursal 12, iremos a nuestro arreglo de registros, y en la posición 12 incrementaremos el
contador de ventas y sumaremos en el acumulador de monto que se encuentran en dicha
posición.
Finalmente, cuando se haya recorrido todo archV y actualizado los datos en todas las posiciones
de nuestro arreglo de registros, podremos recorrerlo de comienzo a fin en la fase de cierre e ir
imprimiendo, línea a línea (es decir, sucursal a sucursal) el Resumen de Ventas que nos piden
como resultado final del ejercicio.
Si no supiéramos que la sucursal (el valor por el cual queremos discriminar) se codifica como
un entero positivo que va de 1 a 40, no podríamos utilizar este valor como índice de un arreglo,
puesto que los índices de un arreglo se manejan con enteros positivos mayores e iguales a 1.

A este arreglo de registros podríamos definirlo como un arreglo que respondería a la siguiente
definición:

Reg-Acum = registro
* cantV: entero
* montoAcum: real
fregistro

Procedamos al desarrollo de dicho algoritmo:

INICIO
CONSTANTES:
MAX = 40

VARIABLES:
archV: archivo de Reg-Ventas //definimos Reg-Ventas más arriba
regV: Reg-Ventas
arrAcum: arreglo [MAX] de Reg-Acum //definimos Reg-Acum más arriba

abrir(archV), E, Secuencial // solo leeremos registros en este archivo

ceros(arrAcum) /* en ceros() debemos inicializar nuestro array antes de empezar a
aumentar contadores en 1 y acumular montos */

4
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -3

leer(archV, regV) U.I

Mientras NO fin(archV) hacer
tratar(regV, arrAcum)
leer (archV, regV)
fMientras
cerrar(archV)
informar(arrAcum)
FIN

/* Se inicializa arrAcum en 0 para que luego podamos acumular en tratar() */

Proced ceros (ref arrAcum: arreglo[MAX] de regAcum)
VAR LOCALES: i: entero
para i desde 1 hasta MAX hacer
arrAcum[i].cantV ← 0
arrAcum[i].montoAcum ← 0
fPara
fProced

/* Procesamos cada registro dentro de tratar() */

Proced tratar(val regV: Reg-Ventas, ref A: arreglo[MAX] de regAcum)
Si regV.sucursal >= 1 y regV.sucursal <= MAX entonces // validación
A[regV.sucursal].cantV ← A[regV.sucursal].cantV + 1
A[regV.sucursal].montoAcum ← A[regV.sucursal].montoAcum + regV.monto
sino
Mostrar("Sucursal INEXISTENTE")
/* Es el único tipo de validación que podemos hacer por el momento: chequear
que el código de la sucursal se encuentre dentro del rango contemplado de 1 a
MAX. */
fSi
fProced

/* Ya que se procesaron todos los registros y se guardaron todos los cálculos en el arreglo de
registros, la fase de cierre/informe consistirá en ir construyendo el Resumen de Ventas solicitado
a medida que se va recorriendo el arreglo de registros que ya se encuentra completamente
cargado. */
Proced informar (ref acum: arreglo[MAX] de regAcum)
VAR LOCALES: i: entero
Mostrar("RESUMEN DE VENTAS")
Mostrar("Sucursal", "Cantidad de Ventas", "Monto Acumulado")
para i desde 1 hasta MAX hacer
Mostrar(i, arr[i].cantV, arr[i].montoAcum)
fPara
/* Si no hubiese ventas para alguna sucursal, se terminará imprimiendo una línea con
ceros para dicha sucursal, los cuales fueron guardados en el arreglo de registros cuando
se inicializó la estructura en el procedimiento ceros() */
fProced

5
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -3

U.I
Caso II

En este caso, desconocemos la codificación de la sucursal, y por ende no podemos usar el valor
del código de la sucursal como índice (no aplica el direccionamiento directo). Sin embargo,
seguimos sabiendo que como máximo hay MAX = 40 sucursales, y por ende crearemos una tabla
de sucursales que servirá como referencia para ir buscando y agregando los códigos de las
sucursales que vayamos procesando en la lectura del archivo. De esta forma, ahora podremos
vincular los códigos de las sucursales a un índice de un arreglo (el índice de la tabla de
sucursales).
Cuando leamos cada registro del archivo, procederemos a buscar en nuestra tabla si el código
de dicha sucursal ya se encuentra allí. Si no lo está, lo agregaremos a la tabla e inicializaremos el
contador y acumulador correspondientes a dicha sucursal en otra estructura separada de la
tabla de referencia, en donde ahora ambas estructuras estarán vinculadas por la asociación que
hay entre el código de una sucursal y la posición del arreglo en donde se encuentra dicho código
(por ejemplo: si en la tabla de sucursales el código "Palermo 2" se encuentra en la posición 8,
entonces en la posición 8 de un arreglo auxiliar se almacenarán los contadores, acumuladores,
y demás campos que hagan falta para resolver el problema que pida el enunciado). De esta
forma, todo lo referido a la sucursal "Palermo 2" se reduce a operar entre la tabla de referencia
y la estructura auxiliar utilizando el índice número 8... ¡pero para eso fue necesario primero
buscar y encontrar que "Palermo 2" existía en la tabla de referencias en la tabla de sucursales!.
Aquí se entiende por qué esto es computacionalmente más costoso que el Caso I, puesto que
ahora es necesario recorrer la tabla de sucursales posición a posición para ver si encontramos
el código en cuestión, mientras que con el direccionamiento directo no era necesario recorrer
nada ya que el código mismo podía ser usado como índice del arreglo.
Por el contrario, si el código que buscamos sí se encuentra en la tabla de referencia,
actualizaremos los campos pertinentes en la estructura auxiliar, en la misma posición en donde
se encuentra ubicado el código en la tabla de referencia.

La ventaja de este planteamiento, es que funciona para otros tipos de codificación que no sean
necesariamente entero positivo.

El ejemplo anterior quedaría modificado de la siguiente forma:

INICIO
Variables
archV: archivo de regV
regV: registro de regV
arrAcum: arreglo[CMAX] de regAcum //estructura auxiliar para procesamiento
tsuc: arreglo[CMAX] de cadena[4] //tabla donde iremos guardando los códigos
tope: entero //para recorrer tsuc

Ceros(arrAcum, tope)
Abrir (archV), E, Secuencial
leer(archV, regV)
Mientras NO Fin(archV) hacer
Tratar(arrAcum, regV, tsuc, tope)
leer(archV, regV)
fMientras
Cerrar(archV)
Informe(arrAcum, tsuc, tope)

6
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -3

FIN U.I
Proced. Ceros (ref arrAcum: arreglo[CMAX] de regAcum, ref tope: entero)
VAR LOCALES: i: entero
tope ← 0 // a medida que aparezcan nuevos códigos, tope irá aumentando
para i desde 1 hasta CMAX hacer
arrAcum[i].cant ← 0
arrAcum[i].monto ← 0
fpara
fProced

Proced. Informe (ref arrAcum: arreglo[CMAX] de regAcum, ref tsuc: arreglo[CMAX] de

cadena[4], val tope: entero)
VAR LOCALES: i: entero
Mostrar ('Resumen')
Mostrar('Sucursal', 'Cantidad Vendida', 'Monto')
para i desde 1 hasta tope hacer
Mostrar(tsuc[i], arrAcum[i].cant, arrAcum[i].monto)
fpara
fProced
/* Se encarga de buscar un código en la tabla, y devolver la posición (pos) correspondiente al
código en la misma. Si no lo encuentra, agrega el código por primera vez a la tabla, y también
devuelve la posición en la que se ubica el código nuevo en la tabla. El error que podría surgir aquí,
sería que, al querer agregar un código nuevo, no haya más espacio disponible, en cuyo caso error
valdrá verdadero */
Proced BuscarYAgregar (ref tsuc: arreglo[CMAX] de cadena[4], ref tope: entero, val
codigoSucursal: cadena[4], ref pos: entero, ref error: lógico)
error ← falso
pos ← 1
Mientras pos <= tope y tsuc[pos] <> codigoSucursal hacer
pos ← pos + 1
fMientras
Si pos > tope entonces // no lo encontró
Si tope < CMAX entonces // agrega un código nuevo
tope ← tope + 1
tsuc[tope] ← codigoSucursal
sino // ya no hay más espacio para agregar un código nuevo
error ← verdadero
fsi
fSi
fProced
Proced Tratar (ref arrAcum: arreglo[CMAX] de regAcum, val regV: Reg-Ventas, ref tsuc:
arreglo[CMAX] de cadena[4], ref tope: entero)
VAR LOCALES: pos: entero, error: logico
BuscarYAgregar(tsuc, tope, regV.sucursal, pos, error)
Si NO error hacer // entonces se actualizan los valores de arrAcum en pos
arrAcum[pos].cant ← arrAcum[pos].cant + 1
arrAcum[pos].monto ← arrAcum[pos] monto + regV.monto
sino // no hay espacio para agregar un código nuevo
Mostrar ('Hay más de ', CMAX, ' sucursales')
fSi
fProced

7
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -3

U.I
En este esquema, los códigos de sucursal en tSuc y los datos como cantidad y monto de cada
sucursal en arrAcum se encuentran vinculados por sus posiciones. Decir arrAcum[4] y tSuc[4] es
estar refiriéndose a los datos acumulados y al código (respectivamente) de la misma sucursal,
cuyo valor podría ser por ejemplo 'AHKL'.

El defecto con este caso, es que nos vemos obligados a tomar por válidos todos los códigos de
sucursales que vienen en las ventas dentro del archivo de ventas, sin que podamos validar si se
tratan de ventas provenientes de sucursales válidas (lo único que podemos validar, es que la
cantidad de códigos de sucursales no exceda CMAX). Allí es donde entra en juego el siguiente
caso de tablas, en donde contaremos con un archivo maestro contra el cual podremos validar
los códigos de las sucursales de las ventas a procesar.

8
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -3

U.I
Caso III

Este caso es una mejora del caso II, en el sentido de que seguimos sabiendo que hay MAX
sucursales, pero ahora nos dicen que disponemos de un archivo maestro, el cual nos va a servir
para poder validar los códigos que leamos del archivo de movimientos.
Se creará una tabla Sucursales en donde guardaremos los códigos considerados válidos por
pertenecer al archivo maestro. Entonces, en vez de tomar por válidos todos los códigos que
vienen en el archivo de movimientos y usarlos para crear la tabla del caso II, ahora podremos
contrastar los códigos de las sucursales del archivo movimientos contra la tabla que llenaremos
con los códigos de sucursales válidos del archivo maestro.

Siguiendo con el ejemplo que venimos desarrollando, tenemos:

MAX = 40

ArchivoSucursales (CMAX) //archivo maestro que contiene códigos de sucursales válidas

-RegSucursal
* codigo: cadena[4]
* descripcion: cadena[30]

ArchivoVentas
- regV
* Sucursal: cadena[4] (CMAX)
* Cliente
* Monto: real
* Fecha

regAcum = Registro
Cant: entero
Monto: real
fReg

INICIO
VARIABLES
ArchV: archivo de RegV
ArchSuc: archivo de RegSucursal
regV: registro de regV
tablaSucursales: arreglo[CMAX] de regSucursal //tabla de códigos de sucursales
tope: entero
arrAcum: arreglo[CMAX] de regAcum

Ceros(arrAcum, tope, tablaSucursales)

Abrir(ArchV), E, Secuencial
leer(ArchV, regV)
Mientras NO Fin(ArchV) hacer
Tratar(regV, arrAcum, tablaSucursales, tope)
leer(archV, regV)
fMientras
Cerrar(ArchV)
Informe(arrAcum, tablaSucursales, tope)

9
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -3

U.I
FIN

Proced Ceros (ref arrAcum: arreglo[CMAX] de regAcum, ref tope: entero, ref
tablaSucursales: arreglo[CMAX] de regSucursal)
VAR LOCALES: i:entero
para i desde 1 hasta CMAX hacer
arrAcum[i].cant ← 0
arrAcum[i].monto ← 0
fpara
CargarSucursales(tablaSucursal, tope)
fProced

/* Aquí se cargan los códigos de las sucursales que vienen en el archivo maestro */
Proced CargarSucursales (ref tablaSucursal: arreglo[CMAX] de regSucursal, ref tope:
entero)
VARIABLES LOCALES: regSuc: regSucursal
tope ← 0
Abrir(ArchSuc), E, Secuencial
leer(archSug, regSuc)
Mientras NO Fin (ArchSuc) y tope < CMAX hacer
tope ← tope + 1
tablaSucursal[tope] ← regSuc
leer(archSuc, regSuc)
fMientras
/* Si aquí se desea controlar que la cantidad de códigos de sucursal no exceda CMAX y
en consecuencia tener una variable booleana que se active en verdadero, para luego
cortar todo el programa, es perfectamente posible. Por una cuestión de simpleza,
también vamos a aceptar que el archivo maestro se tome como un archivo de referencia
cuya constitución sea la correcta */
Cerrar(ArchSuc)
fProced

Proced Informe (ref arrAcum: arreglo[CMAX] de regAcum, ref tablaSucursales:

arreglo[CMAX] de regSucursal, val tope: entero)
VARIABLES LOCALES: i: entero
Para i desde 1 hasta tope hacer
Mostrar(tablaSucursales[i].descripcion, arrAcum[i].cant, arrAcum[i].monto)
fPara
/* Ahora, además de disponer del código, contamos con la descripción, que puede ser un
texto más amigable y humanamente identificatorio que un código alfanumérico (por
ejemplo: "Sucursal Palermo") */
fProced

10
 TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN
Algoritmos y Estructuras de Datos I-Unidad I -3

U.I
/* Se encarga de buscar el código en la tabla, la cual ya fue cargada con los datos del archivo
maestro. Si lo encuentra, pos guardará el valor de la posición correspondiente a ese código, y
existe valdrá verdadero. Caso contrario, si no se encuentra dicho código, existe valdrá falso */
Proced BuscarSucursal(ref tablaSucursales: arreglo[CMAX] de regSucursal, val tope:
entero, val codigo: cadena[4], ref pos: entero, ref existe: lógico)
pos ← 1
Mientras pos <= tope y codigo <> tablaSucursales[pos].codigo hacer
pos ← pos + 1
fMientras
existe ← pos <= tope
fProced

Proced Tratar (val regV: Reg-Ventas, ref arrAcum: arreglo[CMAX] de regAcum, ref
tablaSucursales: arreglo[CMAX] de regSucursal, val tope: entero)
VAR LOCALES: pos: entero, existe: lógico
BuscarSucursal(tablaSucursales, tope, reg.N.sucursal, pos, existe)
Si existe entonces
arrAcum[pos].cont ← arrAcum[pos].cont + 1
arrAcum[pos].monto ← arrAcum[pos].monto + regV.monto
sino
Mostrar ('Sucursal INEXISTENTE')
fsi
fProced

Actividades
Le pedimos que a continuación realice los ejercicios de la Práctica N° 1 - Sección N° 2.

11