Las colecciones dinámicas son estructuras de datos cuyos
elementos
componentes han sido reservados en tiempos diferentes y por ello han
quedado dispersos en la RAM. Lo más probable es que no haya contiguedad
física entre ellos. Forman un grupo pues han sido conectados unos a
otros mediante el uso de apuntadores (cada uno de ellos tiene
almacenada al menos la dirección física de otro elemento).
Una clase que representa la más simple de las estructuras dinámicas es
el
ArrayList
(arreglo-lista). Se trata de objetos en forma de una lista de otros
objetos, agregables mediante el mensaje
Add, insertables
mediante
Insert,
quitables mediante
RemoveAt
y ordenables mediante
Sort
y que pueden ser accedidos mediante el uso de un
índice
de posición
ocupada bajo la converción
0
es la posición para el
primero.
El atributo
Count
contiene siempre la cantidad de elementos que existen en la estructura.
Ejemplo:
Agregar las cantidades 5, 99, 200, quitar lo que esté en 1,
agregar 333, insertar en posición 1 la cantidad 88 y mostrar todos los
elementos existentes en un
ArrayList.
tarea
{
el objeto a es un System.Collections.
ArrayList
a.
Add(5)
a.
Add(99)
a.
Add(200)
a.
RemoveAt(1)
a.
Add(333)
a.
Insert(1,
88)
el objeto
índice
es una cantidad
variando
índice
desde 0 hasta a.
Count-1
haga
muestre "En la posición ", i, " contiene
", a[
índice]
}
Otra de las clases existentes en la plataforma .NET que fue construida
con la técnica de elementos dispersos en la RAM pero conectados entre
sí es
SortedList
(o lista ordenada). Permite crear
y manipular objetos tipo colección de pares. Cada par está formado por
las
componentes: clave y valor. La clave deben ser caracteres y es la base
del ordenamiento. El valor es cualquier tipo de objetos asociado a la
clave. El atributo
Count
mantiene el número de pares existente. Los comportamientos
Add agrega una
pareja,
IndexOfKey
devuelve la posición de una clave,
GetByIndex
entrega el objeto asociado a un índice,
Contains devuelve
verdadero cuando existe una clave y falso en caso contrario.
Ejemplo:
Créese un diccionario de palabras con persistencia y extensible.
Extensible significa que el diccionario recoja las nuevas palabras
introducida en momentos diferentes y peristencia significa que el
diccionario pueda ser usado en cualquier momento (no solamente durante
una
ejecución).
El usuario podrá usar el diccionario mediante tres comandos:
consultar,
agregar y
ciao.
Note que para que corra el programa debe existir a su lado un archivo
texto con extensión
.txt y llamado
DiccionarioLyR
aunque esté vacío.
En el se conservará la información para que persista entre dos
ejecuciones. Se utilizará cada vez una línea para la palabra y la
siguiente para la definición.
El algoritmo consta de tres secciones:
1. Cargar el diccionario en la estructura dinámica.
2. Diálogo con el usuario por medio de los tres comandos.
3. Al despedirse el usuario se guarda la información para el futuro.
Si analiza detenidamente puede:
1. Compactarse más el algoritmo.
2. Mermar la posibilidad de perder la información:
Imagínese que se pierde la energía electrica. Las actualizaciones
hechas no quedan guardadas.
tarea
{
el objeto i es una cantidad
los objetos palabra, definición, función son caracteres
el objeto archivo es un System.IO.StreamReader(doy "DiccionarioLyR.txt")
el objeto diccionario es un System.Collections.
SortedList
mientras archivo.Peek > = 0 haga:
{
copie archivo.ReadLine en palabra
copie archivo.ReadLine en definición
diccionario.
Add(doy palabra, doy
definición)
}
muestre "Las funciones admitidas son: consultar, agregar y ciao"
entre función
mientras función <> "ciao" haga:
{
es función = "consultar" ?
si:{
entre
palabra
es
diccionario.
Contains(doy
palabra) = verdadero ?
si:{
copie
diccionario.
IndexOfKey(doy
palabra) en i
copie
diccionario.
GetByIndex(doy
i) en definición
muestre definición
}
no: muestre "No existe la palabra
==> ", palabra
}
no:es función =
"agregar" ?
si:{
entre palabra, definición
diccionario.
Add(doy palabra,
doy definición)
}
no: muestre "Comando invalido"
entre función
}
el objeto grabador es un System.IO.StreamWriter(doy
"DiccionarioLyR.txt")
variando i desde 0 hasta diccionario.
Count-1
haga:
{
copie diccionario.
GetKey(doy i) en
palabra
copie diccionario.
GetByIndex(doy i) en
definición
grabador.WriteLine(doy palabra)
grabador.WriteLine(doy definición)
}
grabador.Close
muestre "ciao"
}
