TECNICATURA UNIVERSITARIA EN PROGRAMACIÓN

Algoritmos y Estructuras de Datos I - Unidad I - 8

U.I

TECNICATURA UNIVERSITARIA EN
PROGRAMACIÓN

ASIGNATURA:
ALGORITMOS Y ESTRUCTURAS DE
DATOS I

UNIDAD I
Apartado 8

Actualización en Archivos Secuenciales Indexados

CONTENIDISTA: ING. OMAR GALLO HADDAD

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

U.I
ÍNDICE

Introducción ................................................................................................................................ 3

Esquema básico de trabajo .................................................................................................... 3

Ejemplo - Actualización con alternativa ........................................................................... 6

Actividades ............................................................................................................................... 11

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

U.I
Introducción
La organización secuencial indexada mantiene similitudes con el esquema de actualización de
archivos indexados, aunque seremos capaces de realizar operaciones más complejas de las que
podíamos hacer con esta otra organización.

Esquema básico de trabajo

Nos encontramos en una situación en donde el archivo maestro ArchMae es de organización
secuencial indexada, y ArchNov es de organización secuencial que cumple la función de archivo
de novedades, en base al cual se actualizarán los valores de ArchMae.
La idea de este algoritmo es que, una vez llevada a cabo la actualización, se imprima un informe
en el que se comuniquen todos aquellos registros que tengan clave igual o mayor a un valor
ingresado por el usuario.
En base a esto, tenemos:

ArchMae (secuencial indexado)

RegMaestro = Registro
.clave: tClave // (1)
.datos
fReg

ArchNov (secuencial) // (2)

RegNov = Registro
.identificacion: tClave // (3)
.datos
.tipoNov // (4)
fReg

(1): al tratarse de un archivo secuencial indexado, la clave significa ahora tanto orden como
acceso.

(2): el archivo de novedades (secuencial) no tiene por qué estar ordenado para llevar a cabo la
actualización de un maestro de tipo secuencial indexado.

(3): la clave en este archivo tiene el nombre identificacion, es decir que es del mismo tipo que el
campo clave de ArchMae.

(4): responde a los 3 tipos de movimientos posibles: alta(A), baja(B) y modificación (M).

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

U.I
El marco general del esquema de actualización para

INICIO ActualizacionSecIndexadoConInforme
Variables
reg: regNov
archM: archivo de regMaestro
archN: archivo de regNov

Abrir(archM), E/S, Dinámico // (1)

Abrir (archN), E, Secuencial
leer (archN, reg)
Mientras NO fin (archN) hacer
tratarNovedad(reg)
leer (archN, reg)
fMientras
Cerrar (archN)
Informe()
Cerrar (archM)
FIN

(1): al abrir al archivo como de entrada/salida en forma dinámica, podremos utilizar los
operadores de acceso directo para la actualización, y luego los de búsqueda inexacta para llevar
a cabo el informe final.

Entonces, veremos que lo concerniente a la actualización del archivo secuencial indexado,

mantiene el mismo esquema y operadores de acceso directo que empleábamos para la
actualización de un archivo indexado:

Proced tratarNovedad(val reg: registro de RegNovedad)

VAR LOCAL: existe: lógico
Buscar(archM, reg.identificacion, existe)
Si existe entonces
PosibleBajaOModificacion(regNov)
sino
PosibleAlta(regNov)
fSi
fProced

Proced PosibleBajaOModificacion (val reg: registro de RegNov)

VAR LOCAL: regM: registro de RegMaestro

Segun reg.tipo_de_novedad hacer

'A': Mostrar('Alta ya existente')
'B': borrar(archM, reg.identificacion)
'M': leerD(archM, regM)
regM.datos ← reg.datos
regrabar(archM, regM)
otros: Mostrar('Tipo de novedad errónea')
fSegun
fProced

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

U.I
Proced PosibleAlta (val reg: registro de RegNovedad)
VAR LOCAL: regM: registro de RegMaestro

Segun reg.tipo_de_novedad hacer

'A': regM.clave ← reg.identificacion
regM.datos ← reg.datos
grabar(archM, regM)
'B': Mostrar ('Baja o clave inexistente')
'M': Mostrar ('Modificación o clave inexistente')
otros: Mostrar('Tipo de novedad errónea')
fSegun
fProced

Ahora, una vez finalizada la actualización, se procede a la generación del informe. Como se abrió
al archivo de forma dinámica, podemos hacer uso del operador de acceso inexacto posicionarse()
y leerSig() para llevar a cabo un recorrido secuencial a partir del registro en el que se posicionó
posicionarse() hasta que lleguemos al final del archivo:

INICIO Informe es
VAR LOC: fin: lógico, reg: regMaestro, claveDeseada: tClave

Mostrar('ingrese el valor de la clave desde donde desea recorrer el archivo actualizado')

Ingresar(claveDeseada)
Posicionarse(archM, claveDeseada, fin) // (1)
Si NO fin entonces
leerSig(archM, reg)
Mientras NO fin (archM) hacer // (2)
Mostrar(regM.clave, regM.datos)
leerSig(archM, reg)
fMientras
fSi
...
FIN

(1): posicionarse() ubicará el puntero frente al primer registro de clave mayor o igual a la
deseada, y de no haber ninguna le asignará a fin el valor verdadero.

(2): como se solicita recorrer todos los registros desde aquellos con clave mayor o igual a la
ingresada por el usuario, no hace falta agregar más nada en el Mientras, más allá del control de
fin de archivo.

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

U.I
Ejemplo - Actualización con alternativa
En este caso, realizaremos un ejercicio en el que hay que actualizar un archivo secuencial
indexado, pero con la particularidad de que la lógica de este implica tener que, ante cierta
circunstancia específica, realizar una búsqueda inexacta, explotando las posibilidades que esta
organización de archivos nos brinda.

Vayamos al enunciado:

Actualizar el archivo de STOCK de la siguiente manera: si el tipo de movimiento es 1 (entrada de

mercadería), se suma al artículo-depósito de stock indicado en el archivo de movimientos la
cantidad del movimiento al stock actual. Si no existiera un registro para esa clave (Articulo-
depósito) se dará de alta un registro en Stock con stock actual = cantidad de movimiento de la
entrada. Si el tipo de movimiento es 2 (salida de mercadería) se restará la cantidad del
movimiento al Artículo-depósito indicado, siempre y cuando el registro existiera y el stock
actual fuera mayor o igual a la cantidad solicitada. Si el stock actual queda en 0 se debe dar de
baja el registro del archivo de Stock. En caso de no haber stock suficiente o de no existir el
registro (stock en 0) se buscará un depósito alternativo del mismo artículo que pueda satisfacer
el pedido completamente. Si ninguno de los depósitos del artículo tiene stock suficiente se
rechaza la salida con una leyenda aclaratoria.
Por fin de proceso se desea saber cuál es artículo de mayor stock valorizado. El stock valorizado
se calcula como la suma de stock actual de todos los depósitos del artículo multiplicada por el
precio unitario.
Se deben rechazar registros de movimientos por: artículos inexistentes en el maestro, salidas
con stock insuficiente, códigos de movimiento erróneos.

ARCHIVOARTICULOS (Indexado) ARCHIVOSTOCK (Sec. Ind.)

-REGART -REGSTOCK
. CodArticulo (Clave) . Clave
. Descripción .. Articulo
. PrecioUnitario .. Deposito
. StockActual
ARCHIVOMOVIMIENTOSSTOCK
-REGMOV (Secuencial)
. Articulo
. Deposito
. TipoMovimiento
. CantidadMovimiento

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

U.I
Comentarios:

- Los movimientos van a venir del archivo ARCHIVOMOVIMIENTOSSTOCK, y como es secuencial,

procederemos como siempre hacemos con estos archivos: leerlo registro a registro, y tratar a
cada uno en forma individual.

- Entonces, por cada registro de ARCHIVOMOVIMIENTOSSTOCK buscaremos en

ARCHIVOSTOCK por clave Articulo-Deposito. Si el mismo existe, vemos todas las posibilidades:
* Tipo Movimiento = 1 => sumamos a StockActual y regrabamos

* TipoMovimiento = 2 y CantidadMovimiento < StockActual => restamos a Stock Actual y

regrabamos
* Tipo Movimiento = 2 y CantidadMovimiento = StockActual => Borramos ese Articulo-Deposito
del archivo ARCHIVOSTOCK.
* Tipo Movimiento = 2 y CantidadMovimiento > StockActual (NO ALCANZA) => Tenemos que
buscar otro depósito para ese mismo artículo que tenga capacidad para procesar toda la
CantidadMovimiento junta. Al procedimiento que se va a encargar de esto lo llamaremos
Alternativa().
Ahora, si buscamos por Articulo-Depostivo y el mismo NO existe, vemos todas las posibilidades:
* Tipo de Movimiento 1 => creamos un registro de REGSTOCK y grabamos directamente en
ARCHSTOCK asignándole a StockActual el valor CantidadMovimiento.
* Tipo de Movimiento 2 => estamos en la misma situación que en el caso de arriba, por lo que
hay que llamar a Alternativa().

- Finalmente, nos piden que por fin de proceso encontremos el artículo de mayor stock
valorizado. Esto no lo pudimos hacer a medida que leíamos el archivo de movimientos, ya que
nada nos aseguraba que pasaríamos por absolutamente todos los registros del archivo
ARCHSTOCK, así que vamos a hacer uso de la capacidad de recorrido secuencial de los archivos
Secuencial Indexados para hacer esto directamente en Informe() cuando ya se hayan procesado
todos los movimientos, lo cual llevaremos a cabo aplicando un corte de control. Para cada
artículo nuevo con el que nos vayamos topando en nuestro recorrido, iremos a buscar al
ARCHIVOARTICULOS el PrecioUnitario correspondiente (archivo Indexado, es decir, de acceso
directo).

INICIO ejemplo_actualizacion_con_alternativa
Variables:
Arch: archivo de RegMov
ArchA: archivo de RegArt
ArchS: archivo de RegStock
reg: registro de RegMov

tClave = REGISTRO
* articulo: cadena[4]
* deposito: cadena[4]
fReg

Abrir(arch), E, Secuencial
Abrir(archA), E, Directo
Abrir(archS), E/S, Dinámico

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

leer(arch, reg) U.I

Mientras NO fin(arch) hacer
tratar(reg)
leer(arch, reg)
fMientras
Cerrar(arch)
Informe()
Cerrar(archS)
Cerrar(archA)
FIN

Proced Tratar (val reg: regMov)

VAR LOCALES: existe: lógico, identif: tClave

Buscar(archA, reg.Articulo, existe)

Si existe entonces
identif.articulo ← reg.Articulo
identif.deposito ← reg.Deposito
Buscar(archS, identif, existe)
Si existe entonces
EntradaSalidaExistente(reg)
sino
EntradaSalidaInexistente(reg)
fsi
sino
Mostrar('Movimiento p/articulo inexistente')
fsi
fProced

Proced EntradaSalidaExistente(val reg: registro de RegMov)

VAR LOCALES: regS: registro de RegStock

Segun reg.TipoMovimiento hacer

'1': leerD(archS, regS)

regS.StockActual ← regS.StockActual + reg.CantidadMovimiento
Regrabar(archS, regS)

'2': leerD(archS, regS)

Si regS.StockActual >= reg.cantidadMovimiento entonces
regS.StockActual ← regS.StockActual – reg.CantidadMovimiento
Si regS.StockActual = 0 entonces
Borrar(archS, regS.clave)
sino
Regrabar(archS, regS)
fsi
sino
Alternativa(reg)
fSi

otro: Mostrar('Código inválido')

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

fSegun U.I
fProced

Proced EntradaSalidaInexistente(val reg: registro de RegMov)

VAR LOCALES: regS: registo de RegStock

Segun reg.TipoMovimiento hacer

'1': regS.clave.articulo ← reg.articulo

regS.clave.deposito ← reg.deposito
regS.StockActual ← reg.CantidadMovimiento
Grabar(archS, regS)

'2': Alternativa(reg)

otro: Mostrar('tipo de movimiento erróneo')

fSegun
fProced

Proced Alternativa (valor reg: registro de RegMov)

VAR LOCALES: fin: lógico, regS: regStock, Id: tClave
// se fija el código del artículo, y se deja en blanco el código del depósito
Id.articulo ← reg.Articulo
Id.deposito ← b

posicionarse (archS, Id, fin)

Si NO fin entonces
leerSig(archS, regS)
/* avanzamos en la lectura en base a lo establecido en el enunciado: buscamos
un depósito para el mismo artículo, pero que ahora tenga stock suficiente para
procesar el movimiento completamente */
Mientras NO fin(archS) y regS.clave.articulo = Id.articulo y
regS.StockActual < reg.CantidadMovimiento hacer

leerSig(archS, regS) //leemos hasta encontrar espacio en un depósito

fMientras
Si fin(archS) o regS.clave.articulo <> Id.articulo entonces
Mostrar('Stock insuficiente')
sino
/* habiendo encontrado un depósito alternativo, procedemos a
procesarlo normalmente */
Si regS.StockActual = reg.CantidadMovimiento entonces
Borrar(archS, regS.clave)
sino
regS.StockActual ← regS.StockActual –
reg.CantidadMovimiento
regrabar(regS)
fSi
fSi
sino

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

Mostrar('No hay lugar de donde sacar'') U.I

fSi
fProced

Proced Informe ()

VAR LOCALES: regS: registro de RegStock, regA: registro de RegArt, fin: lógico,
MAXART, artAnt: cadena[4]
SU, SUMAX: real
cont: entero
Id: tClave
existe: lógico

/* como hay que recorrer el archivo completamente para encontrar el producto de mayor
stock valorizado, se le asigna blanco a todos los campos de la clave */
Id.articulo ← b
Id.deposito ← b

posicionarse(archS, Id, fin)

Si NO fin entonces
// todo esto es un Corte de Control sin modular
leerSig(archS, regS)
/* a partir de este punto, se lleva a cabo un corte de control, aunque sin estar
modularizado de la misma forma en se lo hizo cuando se estudió puntualmente
Corte de Control (Apertura(), Proceso(), Cierre())*/
SUMAX ← 0
Mientras NO Fin(archS) hacer
artAnt ← reg.clave.articulo
cont ← 0
Mientras NO fin(archS) y regS.clave.articulo = artAnt hacer
cont ← cont + regS.stockActual
leerSig(archS, regS)
fMientras
Buscar(archA, artAnt, existe)
Si existe entonces
leerD(archA, regA)
SU ← cont * regA.PrecioUnitario
Si SU > SUMAX entonces
MAXART ← artAnt
SUMAX ← SU
fsi
sino
Mostrar('Artículo inexistente)
fSi
fMientras
Mostrar('El Art de max stock valorizado es', MAXART)
sino
Mostrar('No hay stock')
fSi
fProced

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

U.I
Actividades
Le pedimos que a continuación realice los ejercicios de la Práctica N° 3

11