Escenario 4 Estrcutura de Datos

Unidad 2 / Escenario 4
Lectura fundamental
Listas (2), pilas y colas
Contenido
1 Listas (continuación)
2 Pilas
3 Colas
Palabras clave: estructura lineal, lista, pilas, colas.

1. Listas (continuación)
En la Lectura fundamental del Escenario 3, se mostró una de las posibles implementaciones de las
listas. En el presente texto se muestran otras maneras de hacerlo.
1.1. Implementación de listas doblemente encadenadas en anillo con encabezado
La clase VEDLinkedList<E> implementa listas con nodos doblemente encadenados en anillo con
encabezado (en inglés: header), exhibiendo la estructura interna de la clase LinkedList<E> de
Java. En esta estructura de datos, los nodos son capaces de almacenar valores y de apuntar al nodo
anterior y al nodo siguiente en el encadenamiento. Para mayor entendimiento véase la figura 1. Un
nodo, representado con la clase VEDNodo<E>, tiene los siguientes atributos:
• val, valor almacenado por el nodo.
• ant, es un apuntador al anterior nodo en el encadenamiento.
• sig, es un apuntador al siguiente nodo en el encadenamiento.
Figura 1. Representación gráfica de un nodo en una lista doblemente encadenada

Fuente: Sotelo (s.f.)
Cada elemento de la lista se almacena en un nodo por separado. Además, hay un nodo especial
llamado encabezado o header, cuyo valor es null y que tiene como propósito hacer más cómoda
la programación de la estructura de datos. Véase la figura 2.
POLITÉCNICO GRANCOLOMBIANO 2
Figura 2. Representación de la lista como una lista 〈x0, x1, x2, … ,xn-1 〉doblemente encadenada en anillo con encabezado
Por simplicidad, es preferible dibujar los nodos de forma lineal y no circular, como se muestra en la figura 3.
Figura 3. Representación lineal de la lista como una lista doblemente encadenada en anillo con encabezado
La lista vacía se representaría internamente como el encabezado apuntándose a sí mismo. Una

representación de una lista vacía se encuentra en la figura 4.
Figura 4. Representación de la lista vacía como una lista doblemente encadenada en anillo con encabezado
Los atributos de la clase VEDLinkedList<E> son:
• tamaño: una variable de tipo int que almacena el tamaño de la lista, y que será abreviada con la
letra n. Se debe recordar que el tamaño de una lista es el número de elementos que almacena.
• header: un nodo especial llamado el encabezado de la lista. El propósito de su existencia es

facilitar la labor de programar la estructura de datos. Siempre tiene valor null.
¿Sabía que...?
El encabezado no guarda ningún elemento de la lista. Por esta razón,
si el tamaño de la lista es n, entonces habrán n+1 nodos, contando el
encabezado.
La figura 5 muestra el código de Java para declarar la clase VEDLinkedList<E>.
Figura 5. Declaración de la clase VEDLinkedList<E>
1.1.1. Constructor
El método constructor de la clase, que se responsabiliza de crear una nueva lista vacía, debe asegurar
que se cumpla la situación ilustrada en la figura 6.
Figura 6. Estado deseado después de la construcción de una lista vacía

Obsérvese que, en la inicialización de los atributos de la clase, se colocó el tamaño en 0 y se creó el
encabezado con valor null, anterior null y siguiente null, quedando como lo muestra la figura 7.
Figura 7. Estado de la lista después de la inicialización de atributos de VEDLinkedList<E>

¿Falta algo? Poner como anterior y como siguiente del encabezado al mismo encabezado, tal como se
muestra en la figura 8.
Figura 8. Método constructor de la clase VEDLinkedList<E>

La tabla 1 presenta los análisis de complejidad temporal del método constructor para el mejor y el peor caso.
Tabla 1. Análisis de complejidad temporal del método constructor VEDLinkedList (). Modificado de Sotelo (s.f)
Tipo de análisis Complejidad Justificación
Peor caso 0 (1) En todo caso, la complejidad temporal de

0 (1) por que se ejecutan un número
Mejor caso 0 (1) constante de operaciones.
Fuente: elaboración propia
1.1.2. Destructor
Para eliminar todos los elementos de la lista, existe el método clear, cuya implementación debe
asegurar que se pase de la situación presentada en la figura 9a a la situación de la figura 9b.
(a)
(b)
Figura 9. Estados deseados de la lista antes (a) y después (b) de llamar al método clear
Basta con poner como anterior y como siguiente del encabezado al mismo encabezado y asignarle
el valor 0 a la variable tamaño, como lo muestra la figura 10. ¿Qué pasa con los nodos de la lista que
están coloreados de verde? Debido a que no hay forma de llegar a ellos, se convierten en basura y la
memoria que ocupan sería liberada por el Recolector de Basura cuando sea el momento. Se concluye
entonces que, después de las operaciones descritas, la lista queda vacía.
Figura 10. Estado de la lista después de re-encadenar el encabezado consigo mismo y de asignarle cero al tamaño
La figura 11 contiene el método que elimina todos los elementos de una lista.
Figura 11. Método que elimina todos los elementos de la lista

La tabla 2 presenta los análisis de complejidad temporal del método que elimina todos los elementos
de la lista para el mejor y el peor caso.
Tabla 2. Análisis de complejidad temporal del método void clear ( ) Modificado de Sotelo (s.f)
Peor caso 0 (n) Sin considerar el trabajo del Recolector de

basura, la complejidad temporal sería 0(1), pero
Mejor caso 0 (n) considerándolo, la complejidad sería 0(n).
1.1.3. Operación de consulta
Para las operaciones de consulta, modificación, inserción y eliminación es necesario contar con un
método que, dada una posición, entregue el nodo de la lista que guarda el elemento de la posición
dada. Este método es el presentado en la figura 12.
Figura 12. Método que retorna el nodo que se encuentra en una posición de la lista
Si index está entre 0 y tamanho-1, el método getNodo retorna como resultado el nodo que
almacena el elemento de la posición index de la lista; de lo contrario, retorna header. En caso
de que index sea menor que la mitad del tamaño de la lista, sale más barato llegar al nodo yendo
hacia delante de siguiente en siguiente; por otro lado, si index es mayor que la mitad del tamaño
de la lista, sale más barato llegar al nodo yendo hacia atrás de anterior en anterior. Obsérvese que, si
index es igual a la mitad del tamaño de la lista, es igual de pesado ir hacia delante que ir hacia atrás.
La tabla 3, presenta los análisis de complejidad temporal del método que retorna un nodo, dada su
posición en la lista.
Tabla 3. Análisis de complejidad temporal de VedNodo getnodo(int index). Modificado de Sotelo (s.f)

El peor caso ocurre cuando index está cerca
de la mitad de la lista, lo que resulta en una
Peor caso 0 (n) complejidad temporal de O(n) porque se
necesitaría pasar aproximadamente por la
mitad de los nodos.
El mejor caso ocurre cuando index es 0 o
tamanho-l. Si index es 0, el nodo requerido
Mejor caso 0 (1) es el siguiente a header. Si index es
tamanho-l, el nodo requerido es el anterior a
headrer. En ambos casos, la complejidad es 0(1).
Usando el método getNodo es posible consultar el elemento que se encuentra en cierta posición de
la lista, como se muestra en la figura 13.
Figura 13. Método para consultar el valor del elemento en una determinada posición de la lista
Nótese que la complejidad temporal del algoritmo depende completamente del método getNodo,
como se muestra en la tabla 4.
Tabla 4. Análisis de complejidad temporal de E get (int index). Modificado de Sotelo (s.f)

Consultar el elemento de la mitad de la lista
Peor caso 0 (n)
tiene complejidad 0(n).
Consultar el primer o el último elemento de
Mejor caso 0 (1)
la lista tiene complejidad 0(1).
1.1.4. Operación de modificación
Usando el método getNodo es posible modificar el elemento que se encuentra en cierta posición de
la lista, como se muestra en la figura 14.
Figura 14. Método para modificar el valor del elemento en una determinada posición de la lista
Nótese que la complejidad temporal del algoritmo depende completamente del método getNodo,
como se muestra en la tabla 5.
Tabla 5. Análisis de complejidad temporal de E set (int index, E element). Modificado de Sotelo (s.f)

Modificar el elemento de la mitad de la lista
Peor caso 0 (n)
Modificar el primer o el último elemento de
Mejor caso 0 (1)
1.1.5. Operación de inserción
Igualmente, usando el método getNodo es posible insertar un elemento en cierta posición de la

lista (supóngase que v es el valor a insertar y que k es la posición donde se desea insertar este valor).
El procedimiento de inserción es el siguiente:
A. Crear un nuevo nodo cuyo valor sea el elemento que se desea insertar. Esta situación se
representa gráficamente en la figura 15 y el código correspondiente en lenguaje Java se muestra
en la figura 16.
Figura 15. Un nuevo nodo es creado, pero aún no se incluye en la lista
Figura 16. Código para crear un nuevo nodo

B. Con la ayuda de la función getNodo, se obtiene un apuntador b al nodo que almacena el

elemento de la posición index, y se declara a como un apuntador al nodo anterior del nodo b.
Esta situación se representa gráficamente en la figura 17 y el código correspondiente en lenguaje
Java se muestra en la figura 18.
Figura 17. Se prepara la inserción del nuevo nodo en la posición dada

Figura 18. Código para preparar la inserción del nuevo nodo

C. Poner el anterior del nodo nuevo en el nodo a y el siguiente del nodo nuevo en el nodo b. Esta
situación se representa gráficamente en la figura 19 y el código correspondiente en lenguaje
Java se muestra en la figura 20.
Figura 19. El nodo a es asociado como anterior y el nodo b como siguiente al nodo nuevo
Figura 20. Código para asociar el nodo a como anterior y el nodo b como siguiente al nodo nuevo
D. Poner el siguiente del nodo a en el nodo nuevo y el anterior del nodo b en el nodo nuevo. Esta
situación se representa gráficamente en la figura 21 y el código correspondiente en lenguaje Java
se muestra en la figura 22.
Figura 21. El nodo nuevo es asociado como siguiente al nodo a y como anterior al nodo b
Figura 22. Código para asociar el nodo nuevo como siguiente al nodo a y como anterior al nodo b
E. Incrementar el tamaño de la lista en 1. La figura 23 compendia el código presentado en este y los

anteriores pasos y lo incluye dentro de un método diseñado para insertar un elemento.
Figura 23. Código implementado en Java para ejecutar los pasos del proceso de inserción
Como en los anteriores casos, la complejidad temporal del algoritmo depende completamente del
método getNodo, como lo muestra la tabla 6.
Tabla 6. Análisis de complejidad temporal de void add(int index, E element). Modificado de Sotelo (s.f)

Insertar un elemento en la mitad de la lista
Peor caso 0 (n)
Insertar un elemento al principio o al final de
Mejor caso 0 (1)
1.1.6. Operación de eliminación
Usando el método getNodo, también es posible eliminar el elemento ubicado en cierta posición de
la lista (supóngase que k es la posición del elemento que se desea eliminar de la lista). El proceso de
eliminación es el siguiente:
A. Por medio de la función getNodo, se obtiene un apuntador b al nodo que almacena el elemento
de la posición index, se declara a como un apuntador al nodo anterior del nodo b, y se declara c
como un apuntador al nodo siguiente del nodo b. Esta situación se representa gráficamente en
la figura 24 y el código correspondiente en lenguaje Java se muestra en la figura 25.
Figura 24. Tres apuntadores son dispuestos para el nodo que será eliminado y sus vecinos
Figura 25. Código para referenciar tres apuntadores al nodo que será eliminado y sus vecinos
B. Poner el siguiente del nodo a en el nodo c y el anterior del nodo c en el nodo a. Esta situación se
representa gráficamente en la figura 26 y el código correspondiente en lenguaje Java se muestra
en la figura 27.
Figura 26. El nodo a se asocia como anterior al nodo c y el nodo c como siguiente al nodo
Figura 27. Código para asociar el nodo a como anterior al nodo c y el nodo c como siguiente al nodo a
C. Disminuir el tamaño de la lista en 1.
D. Como el elemento xk dejó de ser referenciado por la lista, se volvió basura. Cuando lo decida la
Máquina Virtual de Java, el Recolector de Basura liberará la memoria ocupada por este nodo. Esta
situación se representa gráficamente en la figura 28.
Figura 28. En algún momento, el Recolector de Basura libera la memoria

La figura 29 compendia el código presentado en este y los anteriores pasos y lo incluye dentro de un
método diseñado para eliminar un elemento.
Figura 29. Código implementado en Java para ejecutar los pasos del proceso de eliminación
Nuevamente, se observa que la complejidad temporal del algoritmo depende completamente del
método getNodo. El análisis se muestra en la tabla 7.
Tabla 7. Análisis de complejidad temporal de E remove(int index). Modificado de Sotelo (s.f)

Eliminar un elemento en la mitad de la lista
Peor caso 0 (n)
Eliminar el elemento que está al principio o
Mejor caso 0 (1)
al final de la lista tiene complejidad 0(1).
¿Sabía que...?
Responda los siguientes interrogantes: ¿por qué el algoritmo de eliminación
descrito funciona para eliminar al principio de la lista, para eliminar al final de la
lista y para eliminar en medio de la lista? ¿Tiene algo que ver con el encabezado?
1.2. Implementación con listas doblemente encadenadas
Otra implementación posible para las listas es la que usa nodos doblemente encadenados con
apuntador al primero y al último (de aquí en adelante, se llamará a esta versión VEDLinkedListD<E>).
La figura 30 representa esta implementación con un número n de nodos; mientras que, la figura 31
muestra la misma implementación para una lista vacía.
Figura 30. Representación de la lista como una lista 〈x0, x1, x2, … ,xn-1 〉doblemente encadenada de tipo VEDLinkedListD<E>
Figura 31. Representación una lista vacía como una lista doblemente encadenada de tipo VEDLinkedListD<E>
1.3. Implementación con listas sencillamente encadenadas
Las listas también se pueden implementar con nodos sencillamente encadenados con apuntador
al primero (de aquí en adelante, se llamará a esta versión VEDLinkedListS<E>). En una lista
sencillamente encadenada, los nodos solo tienen valor y apuntador al siguiente. La figura 32 es la
representación gráfica de un nodo; la figura 33 representa esta implementación con un número n de
nodos; finalmente, la figura 34 muestra la misma implementación para una lista vacía.
Figura 32. Representación gráfica de un nodo en una lista sencillamente encadenada

Figura 33. Representación de la lista como una lista 〈x0, x1, x2, … ,xn-1 〉 sencillamente encadenada de tipo VED
LinkedListS<E>.
Figura 34. Representación de una lista vacía como una lista sencillamente encadenada de tipo VEDLinkedListS<E>.
1.4. Comentarios sobre eficiencia
La tabla 8 contiene algunas anotaciones importantes en cuanto a la eficiencia en el uso de recursos de

las cuatro distintas implementaciones de listas que se vieron.
Tabla 8. Cuadro comparativo de las ventajas y desventajas en términos de eficiencia de las distintas implementaciones de listas
Implementación Ventajas Desventajas

•Todos los elementos están contiguos en
memoria principal. •Se debe ejecutar una operación costosa
•No requiere tanta memoria principal cada vez que se llene la capacidad del arreglo
puesto que no hay encadenamientos.
(no importa mucho porque no sucede muy
•Las operaciones de consulta por posición
y modificación por posición son muy frecuentemente).
VEDArrayList
eficientes: 0(1). •Las inserciones al principio de la lista son
•Las inserciones al final de la lista son
ineficientes: O(n).
eficientes cuando no toca crecer la
capacidad del arreglo: 0(1). •Las eliminaciones al principio de la lista son
•Las eliminaciones al final de la lista ineficientes: O(n).
siempre son eficientes 0(1).
Implementación Ventajas Desventajas
• Las operaciones de consulta,

• Las operaciones de consulta, modificación, inserción y eliminación
modificación, inserción y eliminación son ineficientes cerca de la mitad de la
son muy eficientes tanto al principio lista: O(n).
VEDLinkedList como al final de la lista: 0(1). •Las consultas sólo son eficientes al
•Es fácil de implementar debido a la principio y al final de la lista.
presencia de encabezado y a la •Requiere más memoria principal que
ausencia de apuntadores nulos. VEDArrayListKEY <E> puesto que
se deben mantener los encadenamientos.
modificación, inserción y eliminación
son ineficientes cerca de la mitad de la
lista: O(n).
Las operaciones de consulta, •Las consultas sólo son eficientes al
modificación, inserción y eliminación principio y al final de la lista.
VEDLinkedListD
son muy eficientes tanto al principio •Requiere más memoria principal que
como al final de la lista 0(1). VEDArrayListKEY <E> puesto que
se deben mantener los encadenamientos.
•Es difícil de implementar debido a la
ausencia de encabezado y a la presencia
de apuntadores nulos.
Las operaciones de consulta,
son ineficientes cerca de la mitad de la
VEDLinkedListS lista: O(n).
son muy eficientes al principio de la
•Es difícil de implementar debido a la
lista 0(1).
ausencia de encabezado y a la presencia
de apuntadores nulos.
2. Pilas
Una pila (en inglés stack), es una estructura de datos lineal, que solo permite inserciones
y eliminaciones en uno de los extremos, llamado tope. Las figuras 35a, 35b y 35c son ejemplos de
pilas que pueden encontrarse en el mundo real.
(a) (b) (c)

Figura 35. Distintos ejemplos de pilas
Fuente: Freepik (2017)
La clase Stack<E> de Java, que extiende de la clase Vector<E>, representa una pila de elementos
de tipo E y permite realizar, entre otras, las operaciones relacionadas en la tabla 9.
Tabla 9. Algunos métodos de la clase Stack<E>
Implementación Ventajas
E push (E item) Insertar en el tope de la pila el ítem suministrado. Retorna el ítem insertado.
E pop ( ) Elimina y retorna el objeto que se encuentra en el tope de la pila.
E peek ( ) Retorna el objeto que se encuentra en el tope de la pila.
Como todo elemento en una pila, puede ser añadido o eliminado solo por el tope, se cumple que el
último elemento que se inserta es el primer elemento que puede eliminarse, razón por la que se dice
que esta estructura de datos satisface que el último en entrar es el primero en salir (Last-in First-Out en
inglés, abreviado con las siglas LIFO). La figura 36 es una representación esquemática de esta condición.
Figura 36. Representación gráfica de una pila y sus operaciones

Gracias a que la clase Stack<E> extiende de la clase Vector<E>, las pilas en Java están
implementadas con arreglos dinámicos de tamaño variable (vectores) como se muestra en la figura 37.
Figura 37. Representación de una pila en Java por medio de arreglos de tamaño variable
Estando el tope en la última posición del vector, las operaciones push, pop y peek tienen complejidad
temporal O(1), porque las inserciones, eliminaciones y consultas al final de una lista implementada
con arreglos son O(1) todas, con la salvedad de que la complejidad de las inserciones se vuelve O(n)
cuando hay que aumentar el tamaño del arreglo. La tabla 10, contiene el ejemplo de la manera en que
una serie de operaciones afecta una pila.
Tabla 10. Evolución de una pila de cadenas de texto tras una secuencia de operaciones
Estado de la pila Operación Descripción

Stack<String> pila
〈 〉 Crear una pila vacía.
=newStack<String>();
〈"Luz"〉 pila.push("Luz") ; Agregar Luz en el tope de la pila.
〈"Luz","Mar"〉 pila.push("Mar") ; Agregar Mar en el tope de la pila.
〈"Luz","Mar","Sol"〉 pila.push("Sol") ; Agregar Sol en el tope de la pila.
〈"Luz","Mar"〉 pila.push() ; Eliminar el tope de la pila.
〈"Luz","Mar","Mes"〉 pila.push("Mes") ; Agregar Mes en el tope de la pila.

〈"Luz","Mar","Mes","Año"〉 pila.push("Año") ; Agregar Año en el tope de la pila.
〈"Luz","Mar","Mes"〉 pila.pop (); Eliminar el tope de la pila.
〈"Luz","Mar"〉 pila.pop (); Eliminar el tope de la pila.
〈"Luz"〉 pila.pop (); Eliminar el tope de la pila.
〈"Luz","Día"〉 pila.push("Día") ; Agregar Día en el tope de la pila.
〈"Luz","Día","Luz"〉 pila.push("Luz") ; Agregar Luz en el tope de la pila.
〈"Luz","Día"〉 pila.pop (); Eliminar el tope de la pila.
〈"Luz"〉 pila.pop (); Eliminar el tope de la pila.
〈 〉 pila.pop (); Eliminar el tope de la pila.
3. Colas
Una cola (en inglés queue), es una estructura de datos lineal, que permite inserciones en un extremo
(llamado cola) y eliminaciones del otro extremo (llamado cabeza). La figura 38, ejemplifica una cola:
Figura 38. Trabajadores esperando en una cola

Fuente: Freepik (2017)
La interfaz Queue<E> de Java, implementada por la clase LinkedList<E>, representa una cola
de elementos de tipo E que permite realizar, entre otras, las operaciones relacionadas en la tabla 11:
Tabla 11. Algunos métodos de la clase Queue<E>
Implementación Ventajas
Insertar en la cola el ítem suministrado. Retorna verdadero en
boolean offer (E item)
caso de éxito.
E poll ( ) Elimina y retorna el objeto que se encuentra en la cabeza de la cola.
E peek ( ) Retorna el objeto que se encuentra en la cabeza de la cola.
Como todo elemento en una cola puede ser insertado solo en la cola y eliminado solo de la cabeza,
se cumple que el primer elemento que se inserta es el primer elemento que puede eliminarse, razón
por la que se dice que esta estructura de datos satisface que el primero en entrar es el primero en salir
(First-in First-Out en inglés, abreviado con las siglas FIFO). La figura 39, es una representación
esquemática de esta condición.
Figura 39. Representación gráfica de una cola y sus operaciones

La clase LinkedList<E> provee una implementación de colas con nodos doblemente encadenados
en anillo con encabezado, como lo ilustra la figura 40:
Figura 40. Representación de una cola en Java por medio de nodos doblemente encadenados
Estando la cola en la última posición de la lista y la cabeza en la primera, las operaciones offer,
poll y peek tienen complejidad temporal O(1), porque las inserciones, eliminaciones y consultas,
tanto al principio como al final de una lista implementada con nodos doblemente encadenados,
son todas O(1). Obsérvese que no sería muy apropiado implementar colas con arreglos dinámicos de
tamaño variable de tipo ArrayList<E> porque las inserciones y eliminaciones al principio del
arreglo tienen complejidad O(n). La tabla 12, contiene el ejemplo de la manera en que una serie de
operaciones afecta una cola:
Tabla 12. Evolución de una cola de cadenas de texto tras una secuencia de operaciones
Estado de la pila Operación Descripción

Queue<String> cola
〈 〉 Crear una pila vacía.
=newLinkedList<String>();
〈"Luz"〉 cola.offer("Luz") ; Agregar Luz en la cola.

〈"Luz","Mar"〉 cola.offer("Mar") ; Agregar Mar en la cola.
〈"Luz","Mar","Sol"〉 cola.offer("Sol") ; Agregar Sol en la cola.
〈"Mar","Sol"〉 cola.poll() ; Eliminar la cabeza de la cola.
〈"Mar","Sol","Mes"〉 cola.offer("Mes") ; Agregar Mes en la cola.

〈"Mar","Sol","Mes","Año"〉 cola.offer("Año") ; Agregar Año en la cola.
〈"Sol","Mes","Año"〉 pila.poll(); Eliminar la cabeza de la cola.
〈"Mes","Año"〉 pila.poll(); Eliminar la cabeza de la cola.
〈"Año"〉 pila.poll(); Eliminar la cabeza de la cola.
〈"Año","Día"〉 cola.offer("Día") ; Agregar Día en la cola.
〈"Año","Día","Luz"〉 cola.offer("Luz") ; Agregar Luz en la cola.
〈"Día","Luz"〉 pila.poll(); Eliminar la cabeza de la cola.
〈"Luz"〉 pila.poll(); Eliminar la cabeza de la cola.
〈 〉 pila.poll(); Eliminar la cabeza de la cola.
En síntesis...
Además de la implementación de listas presentada en la Lectura fundamental del Escenario 3,

existen otras como la implementación de listas doblemente encadenadas en anillo con encabezado,
la implementación con listas doblemente encadenadas y la implementación con listas sencillamente
encadenadas. Cada una de estas implementaciones tiene ventajas y desventajas comparativas en
términos de eficiencia.
Una pila es una estructura de datos lineal que solo permite inserciones y eliminaciones en uno de los
extremos, llamado tope. Una forma apropiada de representar una pila es por medio del uso de arreglos
dinámicos de tamaño variable.
Una cola es una estructura de datos lineal que permite inserciones en un extremo, llamado cola, y
eliminaciones del otro extremo, llamado cabeza. Una forma apropiada de representar una cola es por
medio del uso de nodos doblemente encadenados en anillo encabezado.
Referencias
Sotelo, A. (s.f.). Implementaciones de listas (parte 2). Bogotá, Colombia.
Sotelo, A. (s.f.). Otras estructuras de datos lineales. Bogotá, Colombia.
Referencias de imágenes y tablas

Awesomecontent / Freepik. (2017). Stack of pebble stones [Gráfica]. Recuperado de https://
www.freepik.com/free-photo/stack-of-pebble-stones_991786.htm#term=stacked spa
stones&page=2&position=5
D3images / Freepik. (2017). Workers waiting in line [Gráfica]. Recuperado de https://www.

freepik.com/free-photo/workers-waiting-in-line_954659.htm#term=workers waiting in
line&page=1&position=9
Freepik. (2017). Stacked books with different colors [Gráfica]. Recuperado de https://www.
freepik.com/free-photo/stacked-books-with-different-colors_1092555.htm#term=stack of
books&page=1&position=4
Sotelo, Alejandro. (s.f.). Abstracción de una cola [Diagrama]. Recuperado de https://poli.instructure.

com/courses/67/files/2391?module_item_id=2123
Sotelo, Alejandro. (s.f.). Abstracción de una pila [Diagrama]. Recuperado de https://poli.instructure.

com/courses/67/files/2391?module_item_id=2123
Sotelo, Alejandro. (s.f.). Algunos métodos de la clase Stack<E>. Recuperado de https://poli.

instructure.com/courses/67/files/2391?module_item_id=2123
Sotelo, Alejandro. (s.f.). Algunos métodos de la interfaz Queue<E>. Recuperado de https://poli.

Sotelo, Alejandro. (s.f.). Declaración de la clase VEDLinkedList<E> [Captura de pantalla].

Recuperado de https://poli.instructure.com/courses/67/files/2431?module_item_id=2121
Sotelo, Alejandro. (s.f.). Estado de la lista antes de llamar al método void clear() [Diagrama].
Sotelo, Alejandro. (s.f.). Estado de la lista después de llamar al método void clear() [Diagrama].
Sotelo, Alejandro. (s.f.). Estado de la lista después de re-encadenar el encabezado consigo mismo
y de asignarle cero al tamaño [Diagrama]. Recuperado de https://poli.instructure.com/courses/67/
files/2431?module_item_id=2121
Sotelo, Alejandro. (s.f.). Estado de la lista después de re-encadenar el encabezado consigo mismo
y de asignarle cero al tamaño [Diagrama]. Recuperado de https://poli.instructure.com/courses/67/
Sotelo, Alejandro. (s.f.). Estado de la lista justo después de la inicialización de los atributos de la
clase VEDLinkedList<E> [Diagrama]. Recuperado de https://poli.instructure.com/courses/67/
Sotelo, Alejandro. (s.f.). Estado deseado después de la construcción de una lista vacía [Diagrama].
Sotelo, Alejandro. (s.f.). Evolución de una cola de cadenas de texto tras una secuencia de operaciones
de ejemplo. Recuperado de https://poli.instructure.com/courses/67/files/2391?module_item_
id=2123
Sotelo, Alejandro. (s.f.). Evolución de una pila de cadenas de texto tras una secuencia de operaciones
de ejemplo. Recuperado de https://poli.instructure.com/courses/67/files/2391?module_item_
id=2123
Sotelo, Alejandro. (s.f.). Método constructor de la clase VEDLinkedList<E> [Captura de pantalla].

Sotelo, Alejandro. (s.f.). Método para consultar el valor del elemento que está en determinada
posición de la lista [Captura de pantalla]. Recuperado de https://poli.instructure.com/courses/67/
Sotelo, Alejandro. (s.f.). Método para eliminar el elemento presente en determinada posición
de la lista [Captura de pantalla]. Recuperado de https://poli.instructure.com/courses/67/
Sotelo, Alejandro. (s.f.). Método para insertar un elemento en determinada posición de la lista
[Captura de pantalla]. Recuperado de https://poli.instructure.com/courses/67/files/2431?module_
item_id=2121
Sotelo, Alejandro. (s.f.). Método para modificar el valor del elemento que está en determinada
posición de la lista [Captura de pantalla]. Recuperado de https://poli.instructure.com/courses/67/
Sotelo, Alejandro. (s.f.). Método que elimina todos los elementos de la lista [Captura de pantalla].
Sotelo, Alejandro. (s.f.). Método que retorna el nodo que almacena el valor que se encuentra en
determinada posición de la lista [Captura de pantalla]. Recuperado de https://poli.instructure.com/
courses/67/files/2431?module_item_id=2121
Sotelo, Alejandro. (s.f.). Representación de la lista 〈x0, x1, x2, … ,xn-1 〉 como una lista doblemente
encadenada en anillo con encabezado [Diagrama]. Recuperado de https://poli.instructure.com/
Sotelo, Alejandro. (s.f.). Representación de la lista 〈x0, x1, x2, … ,xn-1 〉 como una lista doblemente
encadenada de tipo VEDLinkedListD<E> [Diagrama].]. Recuperado de https://poli.instructure.com/
Sotelo, Alejandro. (s.f.). Representación de la lista como una lista sencillamente encadenada de
tipo VEDLinkedListS<E> [Diagrama]. Recuperado de https://poli.instructure.com/courses/67/
Sotelo, Alejandro. (s.f.). Representación de la lista vacía como una lista doblemente encadenada
en anillo con encabezado [Diagrama Recuperado de https://poli.instructure.com/courses/67/
Sotelo, Alejandro. (s.f.). Representación de la lista vacía como una lista doblemente encadenada
de tipo VEDLinkedListD<E> [Diagrama]. Recuperado de https://poli.instructure.com/courses/67/
Sotelo, Alejandro. (s.f.). Representación de la lista vacía como una lista sencillamente encadenada
de tipo VEDLinkedListS<E> [Diagrama]. Recuperado de https://poli.instructure.com/courses/67/
Sotelo, Alejandro. (s.f.). Representación gráfica de los nodos en una lista doblemente encadenada
[Diagrama]. Recuperado de https://poli.instructure.com/courses/67/files/2431?module_item_id=2121
Sotelo, Alejandro. (s.f.). Representación gráfica de los nodos en una lista sencillamente encadenada
[Diagrama]. Recuperado de https://poli.instructure.com/courses/67/files/2431?module_item_id=2121
Sotelo, Alejandro. (s.f.). Representación interna de las colas en Java, a través de nodos
doblemente encadenados [Diagrama]. Recuperado de https://poli.instructure.com/courses/67/
Sotelo, Alejandro. (s.f.). Representación interna de las pilas en Java, a través de arreglos dinámicos
de tamaño variable [Diagrama]. Recuperado de https://poli.instructure.com/courses/67/
Sotelo, Alejandro. (s.f.). Representación lineal de la lista 〈x0, x1, x2, … ,xn-1 〉 como una lista
doblemente encadenada en anillo con encabezado [Diagrama]. Recuperado de https://poli.
Sotelo, Alejandro. (s.f.). Sin título [Diagrama]. Recuperado de https://poli.instructure.com/







Sotelo, Alejandro. (s.f.). Ventajas y desventajas de las implementaciones estudiadas. Recuperado de

https://poli.instructure.com/courses/67/files/2431?module_item_id=2121
Topntp26 / Freepik. (2017). Coin stacks [Gráfica]. Recuperado de https://www.freepik.com/free-

photo/coin-stacks_1246098.htm#term=stack of coins&page=1&position=6
INFORMACIÓN TÉCNICA
Módulo: Estructura de Datos

Unidad 2: Estructuras de datos lineales
Escenario 3: Pilas y colas
Autor: Javier Fernando Niño Velásquez
Asesor Pedagógico: Heidy Liliana Moncada

Diseñador Gráfico: Nicolás Jiménez O.
Asistente: Ginna Quiroga
Este material pertenece al Politécnico Grancolombiano.

Prohibida su reproducción total o parcial.

Escenario 4 Estrcutura de Datos

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Escenario 4 Estrcutura de Datos

Cargado por

Copyright:

Formatos disponibles

Unidad 2 / Escenario 4

Listas (2), pilas y colas

Palabras clave: estructura lineal, lista, pilas, colas.

1.1. Implementación de listas doblemente encadenadas en anillo con encabezado

• val, valor almacenado por el nodo.

• ant, es un apuntador al anterior nodo en el encadenamiento.

• sig, es un apuntador al siguiente nodo en el encadenamiento.

Figura 1. Representación gráfica de un nodo en una lista doblemente encadenada

La lista vacía se representaría internamente como el encabezado apuntándose a sí mismo. Una

Los atributos de la clase VEDLinkedList<E> son:

• header: un nodo especial llamado el encabezado de la lista. El propósito de su existencia es

La figura 5 muestra el código de Java para declarar la clase VEDLinkedList<E>.

Figura 6. Estado deseado después de la construcción de una lista vacía

Figura 7. Estado de la lista después de la inicialización de atributos de VEDLinkedList<E>

Figura 8. Método constructor de la clase VEDLinkedList<E>

Tipo de análisis Complejidad Justificación

Peor caso 0 (1) En todo caso, la complejidad temporal de

Fuente: elaboración propia

Figura 11. Método que elimina todos los elementos de la lista

Tipo de análisis Complejidad Justificación

Peor caso 0 (n) Sin considerar el trabajo del Recolector de

Fuente: elaboración propia

1.1.3. Operación de consulta

Tipo de análisis Complejidad Justificación

Fuente: elaboración propia

Tipo de análisis Complejidad Justificación

Fuente: elaboración propia

1.1.4. Operación de modificación

Tipo de análisis Complejidad Justificación

Fuente: elaboración propia

1.1.5. Operación de inserción

Igualmente, usando el método getNodo es posible insertar un elemento en cierta posición de la

Figura 16. Código para crear un nuevo nodo

B. Con la ayuda de la función getNodo, se obtiene un apuntador b al nodo que almacena el

Figura 17. Se prepara la inserción del nuevo nodo en la posición dada

Figura 18. Código para preparar la inserción del nuevo nodo

E. Incrementar el tamaño de la lista en 1. La figura 23 compendia el código presentado en este y los

Tipo de análisis Complejidad Justificación

Fuente: elaboración propia

C. Disminuir el tamaño de la lista en 1.

Figura 28. En algún momento, el Recolector de Basura libera la memoria

Tabla 7. Análisis de complejidad temporal de E remove(int index). Modificado de Sotelo (s.f)

Tipo de análisis Complejidad Justificación

Fuente: elaboración propia

1.2. Implementación con listas doblemente encadenadas

1.3. Implementación con listas sencillamente encadenadas

Figura 32. Representación gráfica de un nodo en una lista sencillamente encadenada

1.4. Comentarios sobre eficiencia

La tabla 8 contiene algunas anotaciones importantes en cuanto a la eficiencia en el uso de recursos de

Implementación Ventajas Desventajas

• Las operaciones de consulta,

Fuente: Sotelo (s.f.)

(a) (b) (c)

Tabla 9. Algunos métodos de la clase Stack<E>

E pop ( ) Elimina y retorna el objeto que se encuentra en el tope de la pila.

E peek ( ) Retorna el objeto que se encuentra en el tope de la pila.

Fuente: Sotelo (s.f.)

Figura 36. Representación gráfica de una pila y sus operaciones

Estado de la pila Operación Descripción

〈"Luz","Mar","Sol"〉 pila.push("Sol") ; Agregar Sol en el tope de la pila.

〈"Luz","Mar"〉 pila.push() ; Eliminar el tope de la pila.

〈"Luz","Mar","Mes"〉 pila.push("Mes") ; Agregar Mes en el tope de la pila.

〈"Luz"〉 pila.pop (); Eliminar el tope de la pila.

〈"Luz","Día"〉 pila.push("Día") ; Agregar Día en el tope de la pila.