Está en la página 1de 14

2.6.

Listas

Una lista está formada por un número variable de nodos {n1, n2, ... nk} tal que cada elemento (nodo),
salvo el primero, tiene un predecesor en la lista (nj-1 antes de nj) y, todo elemento, salvo el último, tiene
un sucesor1. La lista es una estructura de datos dinámica.

Una lista es una estructura o conjunto de nodos en la cual puede insertarse o borrarse nodos en
cualquier parte de ella.

De acuerdo con la posición física de sus nodos, las listas pueden ser secuenciales o encadenadas; como
se viene enunciando en las pilas. Una lista encadenada es una estructura de datos formada por nodos
de al menos dos campos, donde uno de ellos contiene la información a manipular y el otro contiene la
información que permite localizar el siguiente elemento en la lista según la secuencia dada.

Las listas encadenadas ocupan mas memoria. Las listas secuenciales requieren bloques de memoria
debido a la filosofía de estas listas.

Las operaciones básicas en una lista son:

a. Agregar un nodo Xm en la posición k-ésima.


b. Suprimir un nodo Xm de la posición k-ésima o con la información infox.
c. Actualizar el contenido de un nodo.
d. Buscar el nodo con la información infox.
e. Buscar el nodo k-ésimo de la lista (contar).
f. Cambiar el orden de los nodos en la lista.
g. Determinar el número de nodos y/o la información que hay en la lista (listar).

Figura 2.13. Ejemplo de Lista.

Una de las razones de utilizar estructuras de datos es optimizar al máximo el uso de las mismas
estructuras, la memoria y minimizar el tiempo de proceso.

Algoritmo para agregar un nodo en una lista secuencial al final2.

ADDLISTAS(Lista,dato)

1
A primera vista parece que una lista es semejante a un array lineal, son totalmente diferentes. Por un lado la
lista es una estructura dinámica, su tamaño variar. Aunque las listas secuenciales se trabajan, en general, como
un arreglo, ARR, de dimensión N. Por otro lado, el acceso a un elemento de una lista encadenada es a partir del
que está a disposición de ser procesado.
2
El usuario podrá pasar este algoritmo para manejar la Lista como un arreglo.
40
SEPARAR MEMORIA
info.nodo <- dato
SI Lista = null TH Lista <- nodo
SN p <- Lista
MQ info.p <> null
p <- p + C
FMQ
info.p <- info.nodo
FSI
FINADDLISTAS()

Algoritmo para agregar un nodo (colocar cierta información), después del nodo que tiene información
infox.

ADDLISTA1(Lista, infox, dato)


SI Lista = null TH "información no existe, lista vacia"
SN p <- Lista
MQ info.p <> infox
p <- p+C
SI info.p = null TH "información no existe en la Lista"
SALIR
FSI
FMQ
q <- p
MQ info.p <> null
p <- p+C
FMQ
MQ p >= q
r <- p
p <- p-C
info.r <- info.p
FMQ
info.p <- dato
FSI
FADDLISTA1()

Algoritmo para eliminar un nodo final en una lista secuencial3

SUBLISTAS(Lista,dato)
SI Lista = null TH "la lista no existe"
SN p <- Lista
MQ info.p <> null
q <- p
p <- p + C
FMQ
info.q -> dato
info.q <- null
FSI
FINSUBLISTAS()

3
El lector debe recordar que la eliminación de nodos en una Lista se puede realizar en cualquier parte.
Luis Carlos Torres Soler
Estructuras de Datos 41
Algoritmo para eliminar un nodo que contiene un dato específico

SUBLISTAX(Lista,dato)
SI Lista = null TH "la lista no existe"
SN p <- Lista
MQ info.p <> dato
p <- p + C
FMQ
SI info.p = dato TH info.p = null
SN " la lista no contiene este dato"
FSI
q <- p
MQ info.p <> null
info.q <- info.p
q <- p
p <- p+C
FMQ
FSI
FINSUBLISTAX()

Figura 2.14. Adicionar un nodo en una lista encadenada.

Algoritmo para agregar un nodo al final en una lista encadenada.

ADDLISTAE(Lista,dato)
info.nodo <- dato
link.nodo <-null
SI lista = null TH Lista <- nodo
SN MQ link.p <> null
p <- link.p
FMQ
link.p <- nodo
FSI
FINADDLISTAE()

Figura 2.15. Adicionar un nodo al final.

Algoritmo para eliminar un nodo final en una lista encadenada.

Facultad de Ingeniería
42
SUBLISTAE(Lista,dato)

Figura 2.16. Adicionar un nodo al final.


SI lista = null TH "la lista no existe"
SN p <- Lista
MQ link.p <> null
q <- p
p <- link.q
FMQ
info.p -> dato
link.q <- null
FSI
FINSUBLISTAE()

Algoritmo para eliminar un nodo que tiene información infox, en una lista encadenada.

Figura 2.17. Eliminar un nodo en un lista encadenada.

SUBLISTA1(Lista, infox, dato)


SI Lista = null TH "la lista no existe"
SN p <- Lista
MQ info.p <> infox
q <- p
p <- link.p
FMQ
info.p -> dato
link.q <- link.p
FSI
FSUBLISTA1

Las estructuras encadenadas y secuenciales presentan ventajas y desventajas.

* Las estructuras encadenadas ocupan más memoria, debido al campo que emplean para el
pointer (apuntador) en cada nodo.

* Las estructuras secuenciales requieren memoria continua. No siempre se cuenta con ella. Hay
que separarla.

Ejercicio. Sea que se tiene un stack de disponibles (STACKD), una cola secuencial con información
(COLAI), debe crearse una lista encadenada (LISTAO) de tal forma que la información sea ordenada.
No emplear estructuras adicionales, ordenar en el momento de insertar un nodo.
Luis Carlos Torres Soler
Estructuras de Datos 43
EJERCI10(LISTAO, STACKD, COLAI)
SI STACKD = null TH "Error, no hay área de disponibles"
SALIR
FSI
SI COLAI = null TH "No hay información" SALIR
FSI
MQ STACKD <> null AND COLAI <= BASE
nodo <- STACKD
STACKD <- link.STACKD
link.nodo <- null
info.nodo <- info.COLAI
COLAI <- COLAI + C
SI LISTAO = null TH LISTAO <- nodo
SN x <- LISTAO
SI info.LISTAO > info.nodo TH
link.nodo <- LISTAO
LISTAO <- nodo
SN
MQ info.x < info.nodo AND link.x<> null
x <- link.x
FMQ
FSI
SI link.x = null TH link.x <- nodo
SN link.nodo <- link.x
link.x <- nodo
FSI
FSI
FMQ
SI STACKD = null AND COLAI <= BASE TH "No hay espacio disponible para ,,,"
FSI
EJERCI10()

Figura 2.18. Eliminar un nodo en un lista encadenada.

Ejemplo. Se dan dos listas cuya información hace relevancia a los polinomios P y Q adicionarlos en
una tercera lista R

Alg()
lea polinomios P,Q
PX <- P; QX <- Q
MQ PX >< null & QX >< null
MQ exp.PX > exp.QX
Traer_nodo()
modificar_nodo(exp.QX,Coef.Qx)
anexar_nodo()

Facultad de Ingeniería
44
QX <- link.QX
FMQ
MQ exp.PX = exp.QX
S= Coef.QX + Coef.PX
SI S >< 0 TH Traer_nodo()
modificar_nodo(exp.PX,S)
anexar_nodo
FSI
PX <- link.PX
QX <- link.QX
FMQ
MQ exp.PX < exp.QX
Traer_nodo()
modificar_nodo(exp.PX,Coef.Px)
anexar_nodo()
PX <- link.PX
FMQ
FMQ // se cierra el ciclo mayor
SI PX = null & QX >< null TH MQ QX >< null
Traer_nodo()
modificar_nodo(exp.QX,coef.QX)
Anexar_nodo()
QX <- link.QX
FMQ
FSI
SI PX >< null & QX = null TH MQ PX >< null
Traer_nodo()
modificar_nodo(exp.PX,coef.PX)
Anexar_nodo()
PX <- link.PX
FMQ
FSI
Fin_Alg()

Anexar_nodo() // anexar a la cola un nuevo nodo


SI R = null TH R <- nodo
RX <- R
SN link.RX <- nodo
RX <- link.RX
retornar

Traer_nodo() // localizar un nuevo nodo de memoria disponible


nodo <- dispo
exp.nodo <- 0
Coef.nodo <- 0
link.nodo <- null
retornar

Modificar_nodo(u1,u2)
exp.nodo <- u1
Coef.nodo <- u2
retornar

Luis Carlos Torres Soler


Estructuras de Datos 45
Ejemplo. Se dan dos listas cuya información son los polinomios P y Q adicionarlos en la misma
lista P

Alg()
PX <- P; QX <- Q
MQ PX >< null & QX >< null
MQ exp.PX > exp.QX
PX <- link.PX
FMQ
MQ exp.PX = exp.QX
modificar(coef.PX+coef.QX)
PX <- link.PX
QX <- link.QX
FMQ
MQ exp.PX < exp.QX
Anexar_nodo(exp.QX,coef.QX)
QX <- link.QX
FMQ
FMQ // se cierra el ciclo mayor
SI PX = null & QX >< null TH MQ QX >< null
Anexar_nodo(exp.QX,coef.QX)
QX <- link.QX
FMQ
SALIR
SN SI PX >< null & QX = null TH SALIR
FSI
FSI
Fin_Alg()
modificar(s1) //adicionar coeficientes
coef.PX <- s1
PX <- link.PX;
retornar
Anexar_nodo(x1,x2) //crear un nuevo nodo
traer_nodo(x1,x2)
link.PX <- nodo
PX <- link.PX
retornar
traer_nodo(u1,u2) //localizar un nuevo nodo de memoria disponible
nodo <- dispo
exp.nodo <- u1
coef.nodo <- u2
link.nodo <- null
retornar

Ejercicio. Se tiene dos lista secuenciales (arreglos) con información totalmente ordenada, del mismo
tipo, pero totalmente diferente en ambas; pasar dicha información a una tercera lista con información
totalmente ordenada.

Facultad de Ingeniería
46
2.6.1. Ordenamiento de Listas

Una de las operaciones (necesarias) en computación es el ordenamiento. Ordenar es el proceso por el


cual se obtiene un conjunto de elementos tal que el orden de la información relevante en algún campo
es ascendente (o descendente), es decir:

X1 <= X2 <= X3 <= ... <= Xn

Selección lineal

Este método consiste en intercambiar los elementos menores por el elemento que está en la primera
posición, luego se intercambian los elementos menores por el elemento de la segunda posición, así se
continua sucesivamente con las otras posiciones. En cada posición va quedando el elemento menor
adecuado.

Ejemplo. Sea la lista: 9 5 7 3 8 2

El método de selección lineal realiza paso a paso los siguientes cambios:

1. 5 9 7 3 8 2
5 9 7 3 8 2
3 9 7 5 8 2
3 9 7 5 8 2
2 9 7 5 8 3

2. 2 7 9 5 8 3
2 5 9 7 8 3
2 5 9 7 8 3
2 3 9 7 8 5

3. 2 3 7 9 8 5
2 3 7 9 8 5
2 3 5 9 8 7

4. 2 3 5 8 9 7
2 3 5 7 9 8

5. 2 3 5 7 8 9

Algoritmo para la selección lineal utilizando un arreglo A como lista secuencial.

OSELIN(A,n)
PARA i=1, n-1

Luis Carlos Torres Soler


Estructuras de Datos 47
PARA j=i+1, n
SI A[i] > A[j] TH aux <- A[i]
A[i] <- A[j]
A[j] <- aux
FSI
FPARA
FPARA
FOSELIN()

Método burbuja

En este caso se hace la comparación entre elementos adyacentes; si el elemento de la izquierda es


mayor que el elemento de la derecha, se hace el intercambio. Si no hay intercambio quiere decir que la
lista ya esta ordenada.

Ejemplo. Sea la lista: 4 7 5 8 2 3

1. 4 7 5 8 2 3
4 5 7 8 2 3 *
4 5 7 8 2 3
4 5 7 2 8 3 *
4 5 7 2 3 8 *

2. 4 5 7 2 3 8
4 5 7 2 3 8
4 5 2 7 3 8 *
4 5 2 3 7 8 *
4 5 2 3 7 8

3. 4 5 2 3 7 8
4 2 5 3 7 8 *
4 2 3 5 7 8 *
4 2 3 5 7 8
4 2 3 5 7 8

4. 2 4 3 5 7 8 *
2 3 4 5 7 8 *
2 3 4 5 7 8
2 3 4 5 7 8
2 3 4 5 7 8

5. 2 3 4 5 7 8
2 3 4 5 7 8
2 3 4 5 7 8
2 3 4 5 7 8
2 3 4 5 7 8
Facultad de Ingeniería
48
Algoritmo con el método burbuja, para una lista secuencial (arreglo).

BURBUJA(A,n)
j=1
sw=0
MQ (j<n & sw=0)
sw=1
PARA k=1, n-1
SI A[k] > A[k+1] TH aux <- A[k]
A[k] <- A[k+1]
A[k+1] <- aux
sw <- 0
FSI
FPARA
j=j+1
FMQ
FINBURBUJA()

Ejercicio. Ingresar en una lista secuencial nodos que tienen la información de: código, nombre y
profesión; de tal forma que tanto el código como el nombre tenga orden ascendente, pero la profesión
en orden descendente.

Algoritmos de selección Lineal y Burbuja en listas encadenadas.

LINEALENC(Lista)
p <- Lista
MQ link.p >< null
q <- link.p
MQ q >< null
SI info.p > info.q TH aux <- info.p
info.p <- info.q
info.q <- aux
FSI
q <- link.q
FMQ
p <- link.p
FMQ
FINLINEALENC()

BURBUJAENC(Lista)
p <- Lista
sw=0
MQ (link.p >< null & sw=0)
sw=1
q <- Lista
MQ link.q >< null
t <- link.q
Luis Carlos Torres Soler
Estructuras de Datos 49
SI info.q > info.t TH aux <- info.q
info.q <- info.t
info.t <- aux
sw <- 0
FSI
q <- link.q
FMQ
p <- link.p
FMQ
FINBURBUJAENC()

Algoritmo de burbuja intercambiando nodos en una lista encadenada.

BURBUJAENC2(Lista)
r <- Lista
sw=0
MQ (link.r >< null & sw=0)
sw=1
p <- Lista
t <- Lista
MQ link.p >< null
q <- link.p
SI info.p > info.q TH SI p = Lista TH link.p <- link.q
link.q <- p
Lista <- q
SN aux2 <- link.p
link.p <- link.q
link.q <- link.t
link.t <- aux2
sw <- 0
FSI
FSI
SI p >< Lista TH t <- link.t
p <- link.t
FMQ
r <- link.r
FMQ
FINBURBUJAENC2()

Ejemplo. Se cuenta con M stack encadenados, que poseen información diferente pero del mismo tipo y
ordenadamente. Pasar dicha información a un stack, también encadenado.

ALGM1()
// El algoritmo esta desarrollado considerando que cada stacki posee la información de menor a mayor.
BUSCAR_MENOR(M)
INSERTAR_MENOR(infor)
// el nuevo stack posee la información de mayor a menor
FINALGM1()

BUSCAR_MENOR(R)
i <- 1
Facultad de Ingeniería
50
MQ i<R
k <- i
t <- i+1
MQ t<=R
// se busca cual es el ultimo nodo de los stack que posee la información menor
SI info.stack(i) < info.stack(t) TH k <- i FSI
t <- t+1
FMQ
i <- i+1
FMQ
infor <- info.stack(k)
// se elimina el respectivo nodo del stack k
stack(k) <- link.stack(k)
// se renombra los stack
SI stack(k) = null
TH PARA j=k+1, R
stack(j-1) <- stack(j)
FPARA
R <- R-1
FSI
FINBUSCAR_MENOR(infor,R)

INSERTAR_MENOR(infor)
info.nodo <- infor
SI stack = null TH link.nodo <- null
SN link.nodo <- stack
FSI
stack <- nodo
FININSERTAR_MENOR()

Figura 2.18. Ejemplo de un nodo en lista doblemente encadenada.


4
2.6.2 Listas doblemente encadenadas

Las listas se pueden trabajar con doble encadenamiento, uno hacia adelante, el cual notamos dlink
(sig), y uno hacia atrás, el cual se nota ilink (ant).

Figura 2.19. Ejemplo de una Lista doblemente encadenada.

4
El lector podrá visualizar que por su filosofía no se debe hablar de Stack o Colas doblemente encadenadas.
Luis Carlos Torres Soler
Estructuras de Datos 51
Algoritmo para agregar un nodo al final de una Lista doblemente encadenada.

AGRENC1(Lista,dato)
info.nodo <- dato
dlink.nodo <- null
ilink.nodo <- null
SI Lista = null TH Lista <- nodo
SN p <- Lista
MQ dlink.p >< null
p <- dlink.p
FMQ
dlink.p <- nodo
ilink.nodo <- p
FSI
FINAGRENC1()

Figura 2.20. Ejemplo de una Lista circular encadenada.

Figura 2.21. Ejemplo de una Lista circular doblemente encadenada.

2.6.3. Listas circulares

Las listas circulares, en general, son listas encadenadas en las cuales el último nodo de la Lista
encadena al primer nodo.

2.6.4. Multilistas

Cada nodo de una lista podría tener más de dos áreas para encadenamiento, lo que se notaria, link1,
link2, link3, ..., en cada link puede tenerse una lista, por tal motivo esta lista se llama una multilista.

Ejercicios

1. Escribir el algoritmo para pasar de notación infija a posfija.

2. Considere las siguientes expresiones y páselas a notación posfija:

Facultad de Ingeniería
52
a. X=(Y/X-(U*H+V/H)*S^A)+Y^A
b. Y=Y-T+X-U*H+V/H*S^T+Y^T

Figura 2.22. Ejemplo de una Multilista

3. Determine las condiciones para pasar una notación infija a prefija.

4. Considere las siguientes expresiones y páselas a notación prefija:

a. X=(Y/X-(U*H+V/H)*S^A)+Y^A
b. Y=Y-T+X-U*H+V/H*S^T+Y^T

5. ¿Existe método para pasar de notación posfija a prefija?

Luis Carlos Torres Soler