Módulo 10

Hileras: representaciones de la clase hilera,

implementaciones

Introducción
En el módulo 9 definimos la clase hilera con sus operaciones y se desarrollaron algunos
ejemplos de aplicación con objetos de dicha clase. No obstante, en los ejercicios elabo-
rados no nos preocupamos por la forma como se representaran las hileras dentro de la
máquina. En este módulo veremos las diferentes formas de representar hileras dentro
de un computador.

Objetivos
1. R epresentar objetos de la clase hilera en arreglos de una dimensión.
2. Representar objetos de la clase hilera como listas ligadas.
3. Desarrollar los algoritmos para las diferentes operaciones de la clase hilera, repre-
sentándolas en vectores.
4. Desarrollar los algoritmos para las diferentes operaciones de la clase hilera, repre- El código ASCII se desarrolló en el ámbito
sentándolas como listas ligadas. de la telegrafía y se usó por primera vez comer-
cialmente como un código de teleimpresión
Preguntas básicas impulsado por los servicios de datos de Bell.
1. ¿Cuál es el tipo base para representar hileras como vectores? Bell había planeado usar un código de seis bits,
2. ¿Cuáles son las diferentes formas para representar hileras? derivado de Fieldata, que añadía puntuación
y letras minúsculas al más antiguo código de
Contenidos teleimpresión Baudot, pero se les convenció
10.1 Representación secuencial (en vector) para que se unieran al subcomité de la Agen-
10.2 Representación como listas ligadas cia de Estándares Estadounidense (ASA), que
habían empezado a desarrollar el código ASCII.
Baudot ayudó en la automatización del envío
y recepción de mensajes telegráficos, y tomó
muchas características del código Morse; sin
embargo, a diferencia del código Morse, Baudot
usó códigos de longitud constante. Comparado
con los primeros códigos telegráficos, el código
propuesto por Bell y ASA resultó en una reorga-
nización más conveniente para ordenar listas
(especialmente porque estaba ordenado alfa-
béticamente) y añadió características como la
‘secuencia de escape’. La Agencia de Estándares
Estadounidense (ASA), que se convertiría más
tarde en el Instituto Nacional Estadouniden-
se de Estándares (ANSI), publicó por primera
vez el código ASCII en 1963. El ASCII publicado
en 1963 tenía una flecha apuntando hacia
arriba (↑) en lugar del circunflejo (^) y una
flecha apuntando hacia la izquierda en lugar
del guión bajo (_). La versión de 1967 añadió
las letras minúsculas, cambió los nombres de
algunos códigos de control y cambió de lugar
los dos códigos de control ACK y ESC de la zona
de letras minúsculas a la zona de códigos de
control. ASCII fue actualizado en consecuencia
y publicado como ANSI X3.4-1968, ANSI X3.4-
1977 y, finalmente, ANSI X3.4-1986. Otros
órganos de estandarización han publicado
códigos de caracteres que son idénticos a ASCII.
Estos códigos de caracteres reciben a menudo
el nombre de ASCII, a pesar de que ASCII se
define estrictamente solamente por los es-
tándares ASA/ANSI. El código ASCII también
está incluido en su probable relevo, Unicode,
constituyendo los primeros 128 caracteres (o
los ‘más bajos’) .
Tomado de wikipedia
|114 Ude@-Facultad de Ingeniería
10.1 Representación secuencial (en vector)
En esta representación los caracteres de una hilera se colocan consecutivamente, siendo
cada carácter un dato del tipo primitivo char. Si, por ejemplo, tenemos la hilera S = “peste”,
cada carácter se almacena en una posición del vector, comenzando en la posición 1. El
final de la hilera se controla con un símbolo especial; además, en la posición 0 del vector
tendremos el número de caracteres en el vector (figura 10.1):
0 1 2 3 4 5 6 7 8 9
V 5 p e s t e \n
Figura 10.1
En otras palabras, definimos la clase hilera derivada de la clase vector. Por consiguiente,
podremos usar todos los métodos para manipular vectores. En nuestro caso particular,
usaremos el método longitud y el método datoEnPosicion(i), el cual retorna el dato que
se halla en la posición i del vector. Con esta forma de representación algunas funciones
serán fácilmente implementables. Funciones como longitud, subHilera, concat tendrán
algoritmos fáciles y eficientes. En general, digamos que se definen vectores de tamaño
256 elementos. Para hileras muy cortas se desperdicia memoria, ya que no se utiliza la
totalidad del vector definido. Además, operaciones como inserciones y borrados tendrán
algoritmos no muy eficientes ya que implican mover datos en el vector.
Una de las operaciones a la cual se le ha dedicado mucho esfuerzo buscando que sea lo
más eficiente posible es la función posicion. Un algoritmo para dicha operación, bajo esta
representación secuencial, es:
1. entero posicion(hilera p)
2. entero i, j, m, n
3. m = p.longitud()
4. n = longitud()
5. i=1
6. j=1
7. while i <= m and j <= n do
8. if (datoEnPosicion(j) == p.datoEnPosicion(i)) then
9. i=i+1
10. j=j+1
11. if i > m then
12. return j – i + 1
13. end(if)
14. else
15. j=j–i+2
16. i=1
17. end(if)
18. end(while)
19. return 0
20. fin(posicion)
Este algoritmo tiene el inconveniente de que se devuelve en la hilera que invocó el méto-
do cuando encuentra una desigualdad entre datoEnPosicion(j) y P.datoEnPosicion(i).
Fíjese que cuando el resultado de la comparación de los caracteres de las posiciones i
y j (instrucción 8) es falso ejecuta las instrucciones 15 y 16, las cuales lo que hacen es
devolverse en la hilera que invocó el método (instrucción 15) y posicionarse nuevamente
en el primer carácter de la hilera p (instrucción 16).
 Módulo 10. Hileras: representaciones de la clase hilera, implementaciones

Para evitar este retroceso se puede construir un vector, que llamaremos siguientes,
el cual contendrá en la posición i la posición del carácter de la hilera P con el cual se debe
realizar la siguiente comparación con el carácter de la posición j de la hilera que invocó
el método, y de esta forma no tener que devolvernos en la hilera que invocó el método.
Es decir, si siguientes[6] = 4 significa que cuando se encuentre una desigualdad
entre P.datoEnPosicion(6) y algún datoEnPosicion(J) el carácter datoEnPosicion(J)
habrá que compararlo con P.datoEnPosicion(4), esto es, el contenido de siguientes[6].
Si siguientes[6] es igual a 0 se continuará comparando datoEnPosicion(J + 1) con
P.datoEnPosicion(1).

Teniendo construido el vector siguientes el algoritmo posicion quedará así:

entero posicion(p, t)
m = p.longitud()
n = longitud()
i=1
j=1
while i <= m and j <= n do
if (p.datoEnPosicion (i) == datoEnPosicion (j)) then
i=i+1
j=j+1
if i > m then
return j – i + 1
end(if)
else
if siguientes[i] > 0 then
i = siguientes[i]
else
i=1
j=j+1
end(if)
end(if)
end(while)
return 0
fin(posición)

10.2 Representación como listas ligadas

Para representar hileras como listas ligadas basta definir la clase hilera derivada de la
clase LSL. Teniendo esta definición podremos usar todos los métodos definidos para la
clase LSL. Por ejemplo, si queremos representar la hilera “peste”, tendríamos (figura 10.2):

primero → p → e → s → t → e ┤

Figura 10.2

Con esta representación no tendremos desperdicio de memoria y las operaciones de in-

serción y borrado tendrán algoritmos eficientes.

Veamos ahora algunos algoritmos correspondientes a los métodos definidos. Comence-

mos con el algoritmo para el método subHilera. Recordemos que nuestro método retorna
un objeto de la clase hilera y tiene dos parámetros: uno que indica a partir de cuál posición
se debe hacer la copia (parámetro i) y el otro que indica cuántos caracteres se deben

Algoritmia II 115|
 copiar (parámetro j). Nuestro algoritmo es:

1. hilera subHilera(entero i, entero j)

2. entero k, n
3. hilera s
4. nodoSimple p
5. n = longitud()
6. if (i < 1 or i > n) then
7. write(“parámetro i inválido”)
8. return null
9. end(if)
10. if (j < 1 or j > n – i +1) then
11. write(“parámetro j inválido”)
12. return null
13. end(if)
14. p = primerNodo()
15. k=1
16. s = new hilera()
17. while (k < i) do
18. p = p.retornaLiga()
19. k=k+1
20. end(while)
21. k=1
22. while (k <= j) do
23. s.insertar(p.retornaDato(), s.ultimoNodo())
24. p = p.retornaLiga()
25. k=k+1
26. end(while)
27. return s
28. fin(subHilera)

El parámetro i es el que indica a partir de cuál posición se deben copiar j caracteres, el

cual es el segundo parámetro.

Las instrucciones 2 a 4 definen las variables de trabajo.

En la instrucción 5 se determina la longitud de la hilera que invocó el método, con el fin de

controlar que los parámetros i y j sean válidos.

Las instrucciones 6 a 9 controlan que el parámetro i sea válido.

Las instrucciones 10 a 13 controlan que el parámetro j sea válido.

Las instrucciones 14 a 16 asignan los valores iniciales a las variables de trabajo.

Las instrucciones 17 a 20 ubican a p en el nodo a partir del cual hay que realizar la copia
de j caracteres.

Las instrucciones 22 a 26 copian j caracteres insertando nodos al final de la lista que está
construyendo. Fíjese que utilizamos los métodos insertar y ultimoNodo que corresponden
a la clase LSL.

Consideremos ahora el algoritmo para el método de concatenar. Recuerde que nuestro

método lo llamamos concat, es invocado por un objeto de la clase hilera, tiene como pará-

|116 Ude@-Facultad de Ingeniería

 Módulo 10. Hileras: representaciones de la clase hilera, implementaciones

metro otro objeto de la clase hilera y retorna un nuevo objeto de la clase hilera.

1. hilera concat(hilera t)
2. hilera s
3. nodoSimple p
4. s = copiaHilera()
5. p = t.primerNodo()
6. while (no t.finDeRecorrido(p)) do
7. s.insertar(p.retornaDato(), s.ultimoNodo())
8. p = p.retornaLiga()
9. end(while)
10. return s
11. fin(concat)

El anterior algoritmo concatena la lista s con la lista t creando una nueva lista y dejando
intactas las listas s y t.

Las instrucciones 2 y 3 definen las variables de trabajo.

El método copiaHilera() es un método que, como su nombre lo dice, simplemente cons-

truye una copia de la hilera que lo invoca. Más adelante presentamos el algoritmo corres-
pondiente a este método.

En la instrucción 5 nos ubicamos con p en el primer nodo de la lista t enviada como pa-
rámetro, y en las instrucciones 6 a 9 insertamos todos los nodos de la lista t al final de la
lista s.

1. hilera copiaHilera()
2. hilera s
3. nodoSimple p
4. p = primerNodo()
5. s = new hilera()
6. while (no finDeRecorrido(p)) do
7. s.insertar(p.retornaDato(). s.ultimoNodo())
8. p = p.retornaLiga()
9. end(while)
10. return s
11. fin(copiaHilera)

Ejercicios propuestos
1. Elabore un algoritmo para la operación subHilera considerando las hileras representa-
das como vectores.

2. Elabore un algoritmo para la operación concatenación considerando las hileras repre-

sentadas como vectores.

3. Elabore un algoritmo para la operación inserte considerando las hileras representadas

como vectores.

4. Elabore un algoritmo para la operación borre considerando las hileras representadas

como vectores.

Algoritmia II 117|
 5. Elabore un algoritmo para la operación replace considerando las hileras representadas
como vectores.

6. Elabore un algoritmo para la operación inserte considerando las hileras representadas

como listas ligadas.

7. Elabore un algoritmo para la operación borre considerando las hileras representadas

como listas ligadas.

8. Elabore un algoritmo para la operación replace considerando las hileras representadas

como listas ligadas.

9. Elabore un algoritmo para la operación posición considerando las hileras representa-

das como listas ligadas.

|118 Ude@-Facultad de Ingeniería