ED Unidad 3: Estructuras de datos lineales (listas)

Estructuras de datos Carrera de Software
Ph.D. Franklin Parrales 1
09/03/2022
Estructuras de datos lineales
(listas)
Unidad 3
Material docente compilado por el profesor Ph.D. Franklin Parrales Bravo
para uso de los cursos de Estructuras de Datos

09/03/2022
Objetivo general de la Unidad 3
Implementar estructuras de datos lineales usando objetos
para agilizar el manejo de los datos en la memoria principal
de los programas.

09/03/2022
Contenido
• Listas enlazadas
– Conceptos generales
– Representación gráfica
– Estructura de lista enlazada:
• Clase Lista y constructor nodo de la lista
• Clasificación de listas enlazadas
– Simples, dobles, circulares
– Operaciones básicas: Insertar, buscar, eliminar, recorrido
– Operaciones adicionales: Pilas y colas
• Colecciones genéricas e Iteradores
– Colección List <T> – Listas,
– Stack <T> – Pilas,
– Queue <T> – Colas

09/03/2022
Contenido

09/03/2022
Listas: definición
• Una lista es
– Una colección de 0 o mas elementos
• Si la lista no tiene elementos, se dice que esta vacía
– En una lista, todos los elementos son de un mismo tipo
• Son estructuras lineales, es decir
– Sus elementos están colocados uno detrás de otro
– Cada elemento de una lista se conoce con el nombre de NODO
• Las listas
– Son mucho más flexibles que los arreglos
– Permiten trabajo “dinámico” con un grupo de elementos

09/03/2022
Contenido

09/03/2022
Anatomía de una lista enlazada
• Una lista vinculada consta de :
– Una secuencia de nodos
a b c d
▪ Cada nodo contiene un valor
▪ Y un enlace (puntero o referencia) a otro nodo
▪ El último nodo contiene un enlace a null
▪ La lista podría o no tener una cabecera (header)
myList
▪ myList no es un encabezado, es solo una referencia

09/03/2022
• Para el siguiente ejemplo, cada nodo de la
lista simple es una instancia de la clase que se
muestra aquí.
data
link
10
data
link
15
data
link
7
null
public class IntNode
{
private int data;
private IntNode link;
...
}
Nodos de una lista

09/03/2022
data
link
7
• La porción de datos de cada nodo en este
ejemplo es un int.
link
null
{
private int data;
...
}
data
link
15
Nodos de una lista
data
10

09/03/2022
• Cada IntNode también contiene un enlace que
hace referencia a otro IntNode.
data
15
data
7
{
private int data;
...
}
Nodos de una lista
data
10
link
link
null
link

09/03/2022
Nodos de una lista
10 5 8 2 31
25
25
Contenido Enlace
C S
2 31
25
C S
NODO A
NODO B

09/03/2022
Declaraciones para listas vinculadas
• Una lista puede realizar un seguimiento del nodo
frontal mediante el uso de una variable como head en
este ejemplo
• Tenga en cuenta que head no es un
IntNode, sólo es una referencia a un
IntNode.
data
link
10
data
link
15
data
link
7
null
head

09/03/2022
Declaraciones para listas vinculadas
• Representamos la lista vacía almacenando
null en la referencia al head.
head
null

09/03/2022
Contenido

09/03/2022
Clase Lista
• La clase Lista identifica
una referencia
(puntero) a un objeto
(o null).
• La declaración de la
clase Lista debe
incluir:
– Las variables miembro.
– El/los constructor/es.
– [Opcional] Otros
métodos que vayan a
ser utilizados por
objetos externos.
• Código:
public class Lista
{
NodoLista inicio;
String nombre;
public ListaEnlazada () {
inicio = null;
nombre = null;
}
// Otros métodos
}

09/03/2022
Clase NodoLista
• La estructura de datos
que representa los
nodos de una lista debe
contemplarse como una
clase (NodoLista.java).
• Se debe declarar:
– Las variables miembro
(clave y sig).
– El/los constructor/es.
– El destructor [innecesario
en Java].
– [Opcional] Otros métodos
que vayan a ser utilizados
por objetos externos
• Código:
public class NodoLista {
int clave;
NodoLista sig;
public NodoLista (int dato) {
clave = dato;
sig = null;
}
// otros métodos
}

09/03/2022
Contenido

09/03/2022
Tipos
• De acuerdo a su implementación, las listas
se clasifican en
– Simples
– Doblemente Enlazadas
– Circulares
• De acuerdo a su comportamiento, los
conjuntos lineales se clasifican en
– Listas
– Pilas
– Colas

09/03/2022
Contenido

09/03/2022
Listas enlazadas simples
(SLL: singly linked list)
• Se define como un conjunto de nodos
– Uno detrás de otro
– Del cual siempre se puede conocer al nodo inicial y al final
• De cada nodo de la lista, se conoce
– Un contenido, que es la información que almacena dentro
• Puede ser de cualquier tipo de dato
– Un sucesor único
• Excepto el ultimo nodo
de la lista
10 5 8 2 31
25
25
2 31
25
1

09/03/2022
Lista simple: nivel lógico
• Comportamiento (a/con una lista se puede)
– Crear y Eliminar
– Conocer si esta vacía
– Añadir elementos y removerlos
– Consultar el primer y al ultimo elemento
– Imprimir sus elementos en pantalla
– Buscar un elemento con cierta información en la lista
• Estado:
<listaSimple> ::= <comienzo> + {<ref_nodo>} + <final>
<comienzo> ::= <enlace>
<final> ::= <enlace>

09/03/2022
Listas doblemente enlazadas
• En las listas enlazadas solo se avanza en un
sentido
• En las doblemente, se puede avanzar hacia la
derecha o hacia la izq.
2
Cuando la lista
esta vacia,
header y last,
son iguales a
NULL
I DS
DA
last
header
10 5 8 25 2 31

09/03/2022
• En estas listas cada nodo tiene
– Un predecesor, excepto el primero
– Un sucesor, excepto el ultimo
• Cada nodo ya no tiene un solo enlace, tiene dos, hacia el
siguiente y hacia el anterior
<lde> ::= <comienzo> + {<nodo>}+<ultimo>
<comienzo> :: = <enlace>
<ultimo> :: = <enlace>
<enlace> ::= (<<referencia_nodo>> | NULL)
<nodo> ::= <predecesor>+<contenido>+<sucesor>
<predecesor> ::= <enlace>
<sucesor> ::= <enlace>
< contenido > ::= <<dato>>{<<dato>>}

09/03/2022
Listas circulares
• El avance en las listas enlazadas es
– Solo a la derecha(siguiente)
– Limitado hasta el ultimo nodo
• Hay ocasiones en las que se desearia,
– Poder avanzar ilimitadamente
– Del ultimo nodo, pasar al primero
• last->siguiente = header
10 5 8 2 31
25
last->sig last
3

09/03/2022
Contenido

09/03/2022
TDA Lista
public interface Lista<E> {
public void clear();
public void insert(E item);
public void append(E item);
public E remove();
public void moveToStart();
public void moveToEnd();
public void prev();
public void next();
public int length();
public int currPos();
public void moveToPos(int pos);
public E getValue();
}
Este es un ejemplo de TDA
con el que nuestras
implementaciones de lista
deben coincidir.
Un punto clave a tener en
cuenta aquí: ¡Esto no dice
nada sobre CÓMO se
implementa la lista! Eso viene
después, y usaremos este
TDA para nuestras
implementaciones.

09/03/2022
NodoLista Class (Listas simples)
Asignación dinámica de nuevos elementos de lista.
class NodoLista<E> {
private E element;
private NodoLista<E> next;
// Constructores
NodoLista(E it, NodoLista<E> nextval){
element = it; next = nextval; }
NodoLista(NodoLista<E> nextval) { next = nextval; }
NodoLista<E> next() { return next; }
NodoLista<E> setNext(NodoLista<E> nextval)
{ return next = nextval; }
E element() { return element; }
E setElement(E it) { return element = it; }
}
1

09/03/2022
Posición actual en Listas Simples (1)
Enfoque básico: curr (posición actual) apunta al primer nodo en la partición
derecha. Queremos insertar 10 al comienzo de la partición derecha. No hay
acceso (si está disponible) al nodo con valor 23. ¿Cómo podemos hacer la
inserción?

09/03/2022
Posición actual en Listas Simples (2)
Implementación alternativa: curr apunta al nodo que precede al primer nodo
real en la partición derecha. Ahora podemos hacer la inserción. También tenga
en cuenta el uso del nodo de encabezado. El nodo head elimina casos
especiales en el código.

09/03/2022
Clase para Lista Enlazada Simple (1)
class LList<E> implements Lista<E> {
private NodoLista<E> head;
private NodoLista<E> tail;
protected NodoLista<E> curr;
int cnt;
//Constructores
LList(int size) { this(); }
LList() {
curr = tail = head = new NodoLista<E>(null);
cnt = 0;
}
head
tail

09/03/2022
Clase para Lista Enlazada Simple (2)
public void clear() {
head.setNext(null);
curr = tail = head = new NodoLista<E>(null);
cnt = 0;
}
public void moveToStart() { curr = head; }
public void moveToEnd() { curr = tail; }
public int length() { return cnt; }
public void next() {
if (curr != tail) { curr = curr.next(); }
}
public E getValue() {
assert curr.next() != null :
"Nothing to get";
return curr.next().element();
}
head
tail

09/03/2022
Insertar al inicio de la lista
// Inserto el elemento "it" en la posición de inicio
public void insert(E it) {
head = new NodoLista<E>(it, head));
cnt++; // Aumento el contador
}
10 5 8 2 31
25
tail
head
it
nuevo
head
nuevo->sig = head;
head = nuevo;

09/03/2022
curr
31
Insertar después de la posición actual
// Inserto el elemento "it" en la posición actual
curr.setNext(new NodoLista<E>(it, curr.next()));
if (tail == curr)
tail = curr.next();
cnt++; // Aumento el contador
}
10 5 23 2 31
12
head tail
curr
it
tail
it
tail

09/03/2022
Insertar al final de la lista: Append
public void append(E it) {
tail = tail.setNext(new NodoLista<E>(it, null));
cnt++;
}
31
tail
it
tail

09/03/2022
Buscar
/** @return True if k is in list L, false otherwise */
public static Boolean find(Lista<Integer> L, int k) {
for (L.moveToStart(); L.currPos()<L.length(); L.next())
if (k == L.getValue())
return true;
return false; // k not found
}
10 5 8 2 31
25
tail
head
Busco 25
p p p p
p
Busco 30
p p p p p
p

09/03/2022
Eliminar nodo inicial y devolver el elemento borrado
/** Eliminar y devolver el elemento borrado*/
public E removeHead() {
if (head == null){
return null;
}else{
E it = head.element();
head = head.next();
cnt--;
return it;
}
}
10 5 8 2 31
25
head
it = head.
element();
head
head = head->sig;
tail

09/03/2022
Eliminar nodo no inicial y devolver el elemento borrado
/** Eliminar y devolver el elemento borrado*/
public E remove() {
if (curr.next() == null)
return null;
E it = curr.next().element();
if (tail == curr.next())
tail = curr;
curr.setNext(curr.next().next());
cnt--;
return it;
}
10 5 it 2 31
25
head tail
curr.next()
curr

09/03/2022
Recorrido para mover curr al nodo previo
/** Move curr one step left; no change if already at front */
public void prev() {
if (curr == head) return; // Si el nodo actual es el head,
retorno dado que no tiene nodo previo
NodoLista<E> temp = head; // Inicio el recorrido desde el
nodo head
// Recorro la lista hacia adelante hasta encontrar el
elemento anterior al nodo actual (curr)
while (p.next() != curr)
p = p.next();
curr = p;
}
10 5 8 2 31
25
tail
head
p
curr
p p p
curr

09/03/2022
Recorriendo una lista enlazada simple (1)
head =
SLList<String>
next =
data = "Tom"
Node<String>
next =
data = "Dick"
Node<String>
next =
data = "Ann"
null
Node<String>
nodeRef
Hacer algo con
nodeRef
Hacer algo con
nodeRef
Hacer algo con
nodeRef

09/03/2022
Recorriendo una lista enlazada simple (2)
toString() se puede implementar con un recorrido:
public String toString() {
Node<String> nodeRef = head;
StringBuilder result = new StringBuilder();
while (nodeRef != null) {
result.append(nodeRef.data);
if (nodeRef.next != null) {
result.append(" ==> ");
}
nodeRef = nodeRef.next;
}
return result.toString();
}

09/03/2022
Get/Set curr Position
/** Return position of the current element */
public int currPos() {
NodoLista<E> temp = head;
int i;
for (i=0; curr != temp; i++)
temp = temp.next();
return i;
}
/** Move down list to "pos" position */
public void moveToPos(int pos) {
assert (pos>=0) && (pos<=cnt) :
"Position out of range";
curr = head;
for(int i=0; i<pos; i++)
curr = curr.next();
}

09/03/2022
Extensiones a la Lista Enlazada Simple
static NodoLista freelist = null;
static <E> NodoLista<E> get(E it, NodoLista<E> nextval) {
if (freelist == null)
return new NodoLista<E>(it, nextval);
NodoLista<E> temp = freelist;
freelist = freelist.next();
temp.setElement(it);
temp.setNext(nextval);
return temp;
}
void release() { // Return to freelist
element = null;
next = freelist;
freelist = this;
}

09/03/2022
Usando Freelist
curr.setNext(NodoLista.get(it, curr.next()));
if (tail == curr) tail = curr.next();
cnt++;
}
public E remove() {
if (curr.next() == null) return null;
if (tail == curr.next()) tail = curr;
NodoLista<E> tempptr = curr.next();
tempptr.release();
cnt--;
return it;
}

09/03/2022
2

09/03/2022
Nodos en Listas doblemente enlazadas
class DNodo<E> {
private E element;
private DNodo<E> next;
private DNodo<E> prev;
DNodo(E it, DNodo<E> p, DNodo<E> n)
{ element = it; prev = p; next = n; }
DNodo(DNodo<E> p, DNodo<E> n)
{ prev = p; next = n; }
DNodo<E> next() { return next; }
DNodo<E> setNext(DNodo<E> nextval)
{ return next = nextval; }
DNodo<E> prev() { return prev; }
DNodo<E> setPrev(DNodo<E> prevval)
{ return prev = prevval; }
E element() { return element; }
E setElement(E it) { return element = it; }
}

09/03/2022
Insertar nodo en Listas doblemente
enlazadas
curr.setNext(new DNodo<E>(it, curr, curr.next()));
curr.next().next().setPrev(curr.next());
cnt++;
}
head tail
10 5 21 12 17 6
curr
nuevo
it

09/03/2022
Eliminar nodo en Listas doblemente
enlazadas
public E remove() {
if (curr.next() == tail) return null;
curr.next().next().setPrev(curr);
cnt--;
return it;
}
10 5 21 12 17 6
head tail
curr

09/03/2022
Listas circulares
public class ListaCircular
{
private Nodo lc;
public ListaCircular()
{
lc = null;
}
//...
3
10 5 8 2 31
25
last->sig last

09/03/2022
Insertar nodo en Listas circulares
public ListaCircular insertar(Elemento entrada)
{
Nodo nuevo;
nuevo = new Nodo(entrada);
if (lc != null) // lista circular no vacía
{
nuevo.enlace = lc.enlace;
lc.enlace = nuevo;
}
lc = nuevo;
return this;
}

09/03/2022
Eliminar nodo en una lista circular
El algoritmo para eliminar un nodo de una lista circular es:
1. Búsqueda del nodo que contiene el dato.
2. Se enlaza el nodo anterior con el siguiente.
3. En caso de que el nodo a eliminar sea por el que se
accede a la lista, lc, se modifica lc para que tenga la
dirección del nodo anterior.
4. Por último, el sistema libera la memoria ocupada por el
nodo al anular la referencia

09/03/2022
public void eliminar(Elemento entrada){
Nodo actual;
boolean encontrado = false;
//bucle de búsqueda
actual = lc;
while ((actual.enlace != lc) && (!encontrado)){
encontrado = (actual.enlace.dato == entrada);
if (!encontrado){
actual = actual.enlace;
}
}
encontrado = (actual.enlace.dato == entrada);
// Enlace de nodo anterior con el siguiente
if (encontrado){
Nodo p;
p = actual.enlace; // Nodo a eliminar
if (lc == lc.enlace) // Lista con un solo nodo
lc = null;
else{
if (p == lc){
lc = actual; // Se borra el elemento referenciado por lc,
// el nuevo acceso a la lista es el anterior
}
actual.enlace = p.enlace;
}
p = null;
}
}

09/03/2022
Recorrer una lista circular
public void recorrer(){
Nodo p;
if (lc != null){
p = lc.enlace; // siguiente nodo al de acceso
do {
System.out.println("t" + p.dato);
p = p.enlace;
}while (p != lc.enlace);
}else
System.out.println("t Lista Circular vacía.");
}

09/03/2022
Contenido

09/03/2022
Pila (Stack): un TDA simple
 Uno de los conceptos mas utiles en computacion es la pila o stack
 Es un conjunto de elementos, en la que:
 Los elementos se añaden y se remueven por un solo extremo
 Este extremo es llamado “tope” de la pila
La ultima en llegar,
sera la primera en
salir:
LAST IN, FIRST OUT
LIFO
 Ejemplo:
 Cuando un empleado se va de vacaciones, le llega correo a su escritorio.
 Las cartas se van “apilando”.
 Al regresar de vacaciones, la ultima carga en llegar, sera la primera que revisara
 Al terminar de revisarla, la nueva carta del tope de la pila habra cambiado
 Del “pilo” de cartas, la mas nueva que queda, sera la siguiente en ser revisada
1

09/03/2022
TDA Pila: Definición
• Dada una Pila llamada S
– ¿Qué datos serian importantes conocer sobre la Pila?
– ¿Y que operaciones podriamos efectuar a la misma?
Push(s,elemento1)
Elemento 1
Tope
o Cima
Push(s,elemento2)
Elemento 2
Push(S,elemento3)
Elemento 3
Pop(S)
EstaVacia? No
Si
 Al revisar c/carta, se la “sacaba” de la pila
 elemento = pop(s)
 La operación pop remueve el elemento Tope de
la pila y lo retorna. La pila disminuye su tamaño
 Usemos el ejemplo del correo:
 Al acumularse,
 Cada carta(elemento), era “metida” a la pila:
push(s,elemento)
 La operación push aumenta un elemento a la pila,
y esta aumenta en su tamaño

09/03/2022
Implementación de pilas mediante
listas enlazadas simples
• Dado que toda la acción ocurre en la parte superior de
una pila, una lista enlazada individualmente (SLL) es una
buena manera de implementarla.
• El encabezado de la lista apunta a la parte superior de la
pila.
• Push es insertar un elemento al principio de la lista
• Pop es eliminar un elemento del principio de la lista.
44 97 23 17
myStack:

09/03/2022
Pila: operaciones
EliminarPila(Pila)
Efecto: recibe una pila y la libera completamente
EstaVacia(Pila) retorna -> Boolean
Efecto: Devuelve true si esta vacia y false en caso contrario
Push(pila, elemento)
Efecto: Toma la pila y aumenta su tamaño, poniendo
el elemento en la cima de la pila
Pop(Pila) retorna -> elemento
Efecto: Recibe la pila, remueve el elemento tope y lo retorna
Excepcion: Si la pila esta vacia, produce error
TopePila(Pila) retorna -> elemento
Efecto: Devuelve el elemento cima de la pila
Excepcion: Si la pila esta vacia produce error
InicializarPila(Pila)
Efecto: recibe una pila y la inicializa para su trabajo normal

09/03/2022
TDA pila: definición formal
• En conclusion:
– La pila es un conjunto de elementos
– De los cuales solo conozco y puedo ver el TOPE
• Cada elemento en la pila
– Puede contener informacion de cualquier tipo, es decir, es
generico
<pila> ::= <tope> + {<nodo>}
<tope> ::= <enlace>
<enlace> ::= (<<ReferenciaNodo>> | NULL)
<nodo> ::= <contenido> + <enlace>
<contenido> ::= <<dato>>{<<dato>>}

09/03/2022
Otras operaciones
• Al remover el ultimo elemento de una pila esta queda vacia
– Una vez vacia, no se pueden “sacar” mas elementos de la pila
• Antes de sacar un elemento de la pila
– Debemos saber si la pila Esta Vacia?: EstaVacia(s)
• El tope de la pila siempre esta cambiando
– Deberiamos poder “revisar” el elemento tope de la pila:
TopePila(s)
– Si la pila esta vacia, no debe existir un valor tope
• El tratar de remover elementos o acceder a elementos de una
pila vacia se llama
– SUBDESBORDAMIENTO de la pila

09/03/2022
Un aplicación mas práctica
• El compilador siempre sabe cuando se ha
escrito un paréntesis, o una llave de mas
– ¿Como lo hace?
• Con el uso de pilas, expresiones escritas:
– (a+b)) Mal
– ((a+b) * c / 4*g-h) OK
• Se puede reconocer los paréntesis que no
coinciden
– ¿Como lograr esta aplicación de la pila?

09/03/2022
Análisis del problema
• Cuando los paréntesis coinciden:
– Al final de la expresión
• Total paréntesis izq = Total parentesis der
– En todo momento, en cualquier punto de la expresión
• Cada paréntesis der. esta precedido de uno izq
• Acum. paréntesis der. siempre es <= que Acum. Paréntesis izq
• Por ejemplo:
7 - ((X* ((X+Y)/(J-3)) + Y) / (4-2.5))
(A+B)) + 3 Al final de la
expresion:
Total ( = 1
Total ) = 2
En este punto de la expresion, ya se sabe
que es incorrecta
Acum ( = 1
Acum ) = 2
No se cumple la regla

09/03/2022
Un enfoque natural
 Cuando revisamos una expresión de este tipo:
 Revisamos los paréntesis de la derecha, y buscamos sin tienen “match” en la
izquierda
 Para seguir este enfoque podríamos:
 “Recordar” los paréntesis de la izquierda ( a medida que aparecen:
 El primero en aparecer, será el ultimo en ser “recordado”
 El ultimo en aparecer, será el primero en ser “recordado”
La Pila se utiliza
justamente para
“recordar” de la forma
abajo indicada
Pop el
parentesis )
encontrado
7 - ((X* ((X+Y)/(J-3)) + Y) / (4-2.5))
 Asi, cuando aparece un )
 El primer ( recordado, debe ser su “match”
 En ese momento, este primero recordado, ya puede ser “olvidado”
 Al llegar al final de la expresion, ningun ( deberia ser “recordado”

09/03/2022
APLICANDO PILAS
 Veamos, revisemos justo la expresión anterior
Todos los ),
encontraron su (
7 - ( ( X *( ( X+Y) / ( J- 3) ) +Y) / ( 4- 2) )
(
(
(
(

09/03/2022
Y ahora, el algoritmo
Pila S; /*Se declara una pila s, para almacenar los ( */
Pila_Inicializar(&S);
while(no hayamos leido toda la cadena)
{
//tomar el siguiente simbolo de la expresion
if(simbolo = ‘(‘) /*Almacenarlo*/
Pila_Push(&S,simbolo);
if(simbolo = ‘)’){ /*Buscar match*/
if(Pila_EstaVacia(S)) { /*No hubo match!!*/
return(FALSE)
Pila_Pop(&s);
}
}
if(Pila_EstaVacia(s)) /*Algun simbolo se quedo dentro,
porque no hubo match*/
return TRUE;
Else
return FALSE;

09/03/2022
TDA Cola (Queue)
 Abunda este concepto, en la vida cotidiana
 Cuando vamos al cine, para comprar las entradas
 Cuando estamos en el supermercado, en el banco, etc.
 Como funciona
 Se puede decir que la cola tiene 2 extremos
 FRENTE, Y FINAL
 La computadora las utiliza:
 Para manejar la impresión de
documentos, tiempo compartido, etc.
Queue -> Cola
Cada documento
que se manda a
imprimir es
“encolado”, uno a
uno es enviado a
la impresora
Frente
Final
Final
Frente
 Todo el que llega se ubica al final de la cola
 Todo el que sale, lo hace por el frente de la cola
 La cola es por turno
 El primero en llegar, tiene la seguridad de que sera el
primero en salir:
 FIRST IN FIRST OUT -> FIFO
2

09/03/2022
Queues en un sistema informático
• Cuando un proceso (programa) requiere un
determinado recurso
– Impresora
– acceso al disco en una red
– caracteres en un keyboard buffer
• Operaciones de manipulación de colas
– isEmpty(): retorna true o false
– first(): retorna la copia del valor de la cabeza
– add(v): agrega un nuevo valor al final de la cola
– remove(): elimina, retorna valor de la cabeza

09/03/2022
Operaciones básicas
• Al suponer que existe un TDA Cola, podemos:
– Cola Q;
• Todo TDA presenta operaciones básicas, en este caso:
– EnColar
• Insertar un elemento nuevo a la cola, al final de la misma,
• El final aumenta
– DesEnColar
• Cuando un elemento es removido de la cola
• Remueve el elemento del frente
• Retorna el elemento removido
• No se puede ejecutar si la cola EstaVacia
• Asi como en la pila
– Cualquier intento de acceder a elementos en una Cola Vacía:
• SUBDESBORDAMIENTO DE LA COLA

09/03/2022
Implementación de colas con listas
enlazadas simples (SLL)
• In an SLL you can easily find the successor
of a node, but not its predecessor
– Remember, pointers (references) are one-way
• If you know where the last node in a list is,
it’s hard to remove that node, but it’s easy
to add a node after it
• Hence,
– Use the first element in an SLL as the front of
the queue
– Use the last element in an SLL as the rear of
the queue
– Keep pointers to both the front and the rear of
the SLL

09/03/2022
Estructura Queue
myHead mySize myTail
n
aQueue
. . .
. . .
value0 value1 valuen-1

09/03/2022
Encolando un nodo
Para encolar (add) un nodo:
Encuentra el actual último nodo
Cámbielo para que apunte al nuevo último nodo
Cambiar el último puntero en el encabezado de la lista
17
Nodo a ser
encolado
23
44
last
first
97

09/03/2022
Desencolando un nodo
• Para desencolar (remove) un nodo:
– Copiar el puntero del primer nodo en el
encabezado
44 97 23 17
last
first

09/03/2022
Métodos de clase Queue
• Constructor
– set myHead, myTail to null
– set mySize to zero
• isEmpty()
– return results of comparison mySize == 0
• front()
– return myHead.getValue()
// unless empty

09/03/2022
Métodos de clase Queue
• add()
– create new node, update attribute variables
– if queue is empty, must also update myHead
• remove()
– must check if class not empty
otherwise …
– save handle to first object
– adjust head to refer to node
– update mySize

09/03/2022
Deques
• Un deque es un double-ended queue
• Las inserciones y eliminaciones pueden
ocurrir en cualquier extremo
• La implementación es similar a la de las
colas
• Los deques no se utilizan mucho
• Deberías saber qué es un deque, pero no
los exploraremos mucho más.

09/03/2022
Contenido
– Estructura de lista enlazada: Clase Lista y constructor nodo de la
lista

09/03/2022
La interfaz Collection
• Excluye
– add(int, E)
– get(int)
– remove(int)
– set(int, E)
• Pero incluye
– add(E)
– remove(Object)
– El método iterator

09/03/2022
The Collection Framework
<<interface>>
Iterable<
<<interface>>
Collection
<<interface>>
Queue<
<<interface>>
List<
AbstractCollection
<<interface>>
Set
<<interface>>
Deque
AbstractList AbstractSet
<<interface>>
SortedSet
AbstractSequential
List
Vector ArrayList HashSet
<<interface>>
NavigableSet<
TreeSet
ConcurrentSkipListSet
LinkedList Stack
LinkedHashSe
t

09/03/2022
Características comunes de las colecciones
• crecen según sea necesario
• tienen referencias a objetos
• al menos dos constructores
– uno para crear una colección vacía
– uno para hacer una copia de otra colección

09/03/2022
general Collection
 el orden de los elementos no está especificado
Colecciones que implementan la interfaz List
 el orden de los elementos está determinado por el índice

09/03/2022
 Para una Collection general
 la posición donde se inserta un objeto no es especificada
 Pero para ArrayList y LinkedList
 add(E) siempre inserta al final y siempre retorna true

09/03/2022
Contenido
lista

09/03/2022
Interfaz java.util.List y sus
implementaciones

09/03/2022
La clase LinkedList
• Dado
LinkedList alist = new LinkedList();
. . .
aList.add(new(integer(88));
Objeto resultante
mostrado a la
izquierda
aList
head size tail
3
66
88 77
https://docs.oracle.com/javase/7/docs/api/java/util/LinkedList.html

09/03/2022
Recordando: Variaciones en listas enlazadas
• Las listas se pueden enlazar doblemente
como se muestra en la figura anterior
• Las listas también se pueden enlazar en una
sola dirección
– El atributo podría no necesitar un enlace a la cola
– El nodo necesita un enlace hacia adelante y un
puntero solo a los datos.
– El último elemento de la lista tiene un enlace
establecido en nulo
• Las listas se pueden enlazar circularmente
– El último nodo tiene un enlace al primer nodo

09/03/2022
Usando la clase LinkedList
• Dado
LinkedList addressSequence = new LinkedList();
• Use el constructor de una LinkedList
para construir una lista vacía
head size tail
0
addressSequence

09/03/2022
Agregar nodos a la lista vinculada
• Resultados del comando para la primera
adición de nodos a la lista
addressSequence.add(anAddressCounter);
head size tail
0
addressSequence
123.111.345.444, 1
Sucesivas adiciones…
•Crean más nodos y valores de datos
•Ajustan enlaces

09/03/2022
Acceder a valores en una LinkedList
• Debe usarse el método .get
((AddressCounter)addresssSequence.get(index)).incrementCount();
• Una LinkedList no tiene una matriz con un índice
para acceder a un elemento
• El método get debe …
– Iniciar en el nodo head cabecera
– iterar a través de los nodos index para encontrar
coincidencias
– devolver la referencia del objeto en ese nodo
• La sentencia luego hace cast y incrementCount()

09/03/2022
• Para imprimir valores sucesivos para la salida
for (int i = 0; i < addressSequence.size(); i++)
System.out.println(addressSequence.get(i));
size method determina el
límite del contador del ciclo
for
get(i) inicia en el
primer nodo, itera i
veces para alcanzar el
nodo deseado
•Note que cada get(i) debe pasar sobre los mismos primeros i-1
nodos previamente accesados -> O(n2)
•¡Esto es ineficiente!

09/03/2022
• Alternativa: algoritmo con acceso más eficiente
ListIterator it = addressSequence.listIterator();
while (it.hasNext())
System.out.println( it.next());
• ListIterator es un objeto que itera a través
de los valores en una lista
• El método next() hace lo siguiente:
1. guarda el identificador en el objeto del nodo actual
2. avanza el iterador al siguiente nodo usando el atributo
sucesor
3. devuelve el identificador guardado en el paso 1, por lo
que el objeto al que se apunta se puede generar

09/03/2022
El Iterador (Iterator)
• Un iterador se puede ver como un marcador de lugar
en movimiento que realiza un seguimiento de la
posición actual en una lista enlazada en particular.
• Un objeto iterador para una lista comienza en el
primer nodo
• El programador puede mover el iterador llamando a su
método next()
• El iterador permanece en su elemento de lista actual
hasta que es necesitado
• Un iterador recorre la lista en O(n) mientras que un
recorrido de lista que usa llamadas get() en una lista
vinculada es O(n2)

09/03/2022
Insertar nodos en cualquier lugar de
una lista enlazada
• Recordar problema con ArrayList
– se puede agregar solo al final de la lista
– LinkedList tiene capacidad para insertar nodos en
cualquier lugar
• Nosotros podemos decir
addressSequence.add(n, new AddressCounter());
lo cual hará…
– construir un nuevo nodo
– actualizar enlaces a head y tail si es necesario
– actualizar los enlaces del controlador de nodo para
colocar el nuevo nodo en el n-ésimo elemento de la lista
– asignar memoria para el elemento de datos

09/03/2022
La clase LinkedList

09/03/2022
Interface Iterator
• La interface Iterator está definida en java.util
• La interface List a el método iterator, el cual
retorna un objeto Iterator que itera sobre los
elementos de esa lista

09/03/2022
Eliminación de elementos usando Iterator (1)
• Puedes usar el método remove() para eliminar
elementos de una lista a medida que accede a
ellos
• remove() elimina el elemento más reciente
retornado (devuelto)
• Debe llamar a next() antes de cada
remove(); de lo contrario, se lanzará una
IllegalStateException
• Para eliminar todos los elementos de una lista de
tipo Integer que son divisibles por un valor
particular…

09/03/2022
Eliminación de elementos usando Iterator (2)
public static void removeDivisibleBy(LinkedList<Integer>
aList, int div)
{
Iterator<Integer> iter = aList.iterator();
while (iter.hasNext()) {
int nextInt = iter.next();
if (nextInt % div == 0) {
iter.remove();
}
}
}

09/03/2022
Interface ListIterator (1)
• Iterator limitations
– Traverses List only in the forward direction
– Provides a remove method, but no add
method
– You must advance the Iterator using your
own loop if you do not start from the
beginning of the list
• ListIterator extends Iterator,
overcoming these limitations

09/03/2022
• Limitaciones del Iterator
– Se recorre la lista solo en dirección hacia adelante
– Proporciona un método remove, pero no un método
add.
– Debe avanzar el Iterator usando su propio bucle si
no comienza desde el principio de la lista
• ListIterator extiende Iterator, superando
estas limitaciones

09/03/2022
• Al igual que con Iterator, ListIterator se
posiciona conceptualmente entre los elementos de
la lista
• Las posiciones ListIterator van de 0 a size

09/03/2022

09/03/2022
Comparación entre Iterator y
ListIterator
• ListIterator es una subinterface de Iterator
– Las clases que implementen ListIterator deben
proporcionar las características de ambos
• Iterator:
– Requiere menos métodos
– Puede iterar sobre estructuras de datos más generales
• Iterator es requerido por la interfaz Collection
– ListIterator es requerido solo por la interfaz List

09/03/2022
Conversión entre ListIterator y un
Index (1)
• ListIterator:
– nextIndex()retorna el index del item a ser
retornado por next()
– previousIndex() retorna el index del item a
ser retornado por previous()
• LinkedList dispone del método listIterator(int
index)
– Retorna un ListIterator posicionado de
manera que next()retornará el item de la
posición index

09/03/2022
Conversión entre ListIterator y un
Index (2)
• El método listIterator (int index)
crea un nuevo ListIterator que
empieza en el inicio, y recorre la lista
hasta la posición deseada – generalmente
se trata de una operación O(n)

09/03/2022
Mejora en declaración for(1)
• Java 5.0 introduce una mejora para la declaración for
• La mejora en la declaración for crea un objeto
Iterator e implícitamente llama a los métodos
hasNext y next
• Otros métodos Iterator, como remove, no están
disponibles
• El Código siguiente contabiliza el número de veces
que target aparece en myList (type
LinkedList<String>)
count = 0;
for (String nextStr : myList) {
if (target.equals(nextStr)) {
count++;
}
}

09/03/2022
• En la lista myList de tipo type
LinkedList<Integer>, cada objeto Integer
es automaticamente desempaquetado:
sum = 0;
for (int nextInt : myList) {
sum += nextInt;
}

09/03/2022
• La instrucción for mejorada también se puede
usar con matrices, en este caso, chars o type
char[]
for (char nextCh : chars) {
System.out.println(nextCh);
}

09/03/2022
Interface Iterable
Each class that implements the List interface must
provide an iterator method
The Collection interface extends the Iterable
interface
All classes that implement the List interface (a
subinterface of Collection) must provide an iterator
method
Allows use of the Java 5.0 for-each loop
public interface Iterable<E> {
/** returns an iterator over the elements in this
collection. */
Iterator<E> iterator();
}

09/03/2022
Ejemplo de uso LinkedList
import java.util.*;
public class LinkedList1{
public static void main(String args[]){
LinkedList<String> al=new LinkedList<String>();
al.add("Ravi");
al.add("Vijay");
al.add("Ravi");
al.add("Ajay");
Iterator<String> itr=al.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
}
}

09/03/2022
Ejemplo
LinkedList
para
agregar
elementos
import java.util.*;
LinkedList<String> ll=new LinkedList<String>();
System.out.println("Initial list of elements: "+ll);
ll.add("Ravi");
ll.add("Vijay");
ll.add("Ajay");
System.out.println("After invoking add(E e) method: "+ll);
//Adding an element at the specific position
ll.add(1, "Gaurav");
System.out.println("After invoking add(int index, E element) method: "+ll);
LinkedList<String> ll2=new LinkedList<String>();
ll2.add("Sonoo");
ll2.add("Hanumat");
//Adding second list elements to the first list
ll.addAll(ll2);
System.out.println("After invoking addAll(Collection<? extends E> c) method: "+ll);
ll3.add("John");
ll3.add("Rahul");
//Adding second list elements to the first list at specific position
ll.addAll(1, ll3);
System.out.println("After invoking addAll(int index, Collection<? extends E> c) method: "+ll);
//Adding an element at the first position
ll.addFirst("Lokesh");
System.out.println("After invoking addFirst(E e) method: "+ll);
//Adding an element at the last position
ll.addLast("Harsh");
System.out.println("After invoking addLast(E e) method: "+ll);
}
}

09/03/2022
Ejemplo
LinkedList
para
remover
elementos
import java.util.*;
public class LinkedList3 {
public static void main(String [] args) {
ll.add("Ravi"); ll.add("Vijay"); ll.add("Ajay"); ll.add("Anuj"); ll.add("Gaurav"); ll.add("Harsh"); ll.add("Virat");
ll.add("Gaurav"); ll.add("Harsh"); ll.add("Amit");
System.out.println("Initial list of elements: "+ll);
//Removing specific element from arraylist
ll.remove("Vijay");
System.out.println("After invoking remove(object) method: "+ll);
//Removing element on the basis of specific position
ll.remove(0);
System.out.println("After invoking remove(index) method: "+ll);
ll2.add("Ravi");
ll2.add("Hanumat");
// Adding new elements to arraylist
ll.addAll(ll2);
System.out.println("Updated list : "+ll);
//Removing all the new elements from arraylist
ll.removeAll(ll2);
System.out.println("After invoking removeAll() method: "+ll);
//Removing first element from the list
ll.removeFirst();
System.out.println("After invoking removeFirst() method: "+ll);
//Removing first element from the list
ll.removeLast();
System.out.println("After invoking removeLast() method: "+ll);
//Removing first occurrence of element from the list
ll.removeFirstOccurrence("Gaurav");
System.out.println("After invoking removeFirstOccurrence() method: "+ll);
//Removing last occurrence of element from the list
ll.removeLastOccurrence("Harsh");
System.out.println("After invoking removeLastOccurrence() method: "+ll);
//Removing all the elements available in the list
ll.clear();
System.out.println("After invoking clear() method: "+ll);
}
}

09/03/2022
Ejemplo LinkedList para invertir una
lista de elementos
import java.util.*;
ll.add("Ravi");
ll.add("Vijay");
ll.add("Ajay");
//Traversing the list of elements in reverse order
Iterator i=ll.descendingIterator();
while(i.hasNext())
{
System.out.println(i.next());
}
}
}

09/03/2022
Ejemplo de Java LinkedList: Libro
import java.util.*;
class Book {
int id;
String name,author,publisher;
int quantity;
public Book(int id, String name, String author, Strin
g publisher, int quantity) {
this.id = id;
this.name = name;
this.author = author;
this.publisher = publisher;
this.quantity = quantity;
}
}
}
public class LinkedListExample {
public static void main(String[] args) {
//Creating list of Books
List<Book> list=new LinkedList<Book>();
//Creating Books
Book b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8);
Book b2=new Book(102,"Data Communications & Networking",
"Forouzan","Mc Graw Hill",4);
Book b3=new Book(103,"Operating System","Galvin","Wiley",6);
//Adding Books to list
list.add(b1);
list.add(b2);
list.add(b3);
//Traversing list
for(Book b:list){
System.out.println(b.id+" "+b.name+" "+b.author+" "+b.publisher+"
"+b.quantity);
}
}

09/03/2022
Contenido
lista

09/03/2022
Clase Stack de Java
• Java tiene una clase Stack que extiende la
clase Vector
• El autor señala que la implementación como
una subclase de Vector proporciona herencia
de métodos inapropiados para una pila (Stack)
– esto viola la regla de oro para el uso de la extensión
– Vector contiene mensajes no apropiados que no
deben usarse en Stack

09/03/2022
java.util.Stack
• El TDA Stack, como se indica en
java.util.Stack:
– Stack(): método constructor
– boolean empty() (pero tambien hereda isEmpty())
– Object push(Object item)
– Object peek(): devuelve el elemento que esta en la
cima de la pila
– Object pop()
– int search(Object o): Devuelve la 1-based posición
del objeto en la pila
• 1-based, inclusive start, inclusive end
– Describing entire sequence : start = 1, end = 8 Ej:[1,2,3,4,5,6,7,8]
• 0-based, inclusive start, exclusive end
– Describing entire sequence: start = 0, end = 8 Ej: [0,1,2,3,4,5,6,7]

09/03/2022
Ejemplo de uso
//Pilas: Comandos basicos (push, pop, peek, empty)
package pilas;
import java.util.Stack;
public class Pilas {
public static void main(String[] args) {
Stack < String > pila = new Stack < String > ();
//apila 3 elementos
pila.push("elemento1");
System.out.println("1- push: " + pila);
//retira elemento que esta en la cima de la pila
pila.pop();
System.out.println("2- pop: " + pila);
//devuelve el elemento que esta en la cima de la pila
String x = pila.peek();
System.out.println("3- peek: " + x);
//devuelve cierto si la pila esta vacia
boolean y = pila.empty();
System.out.println("4- empty: " + y);
}
}
run:
1- push: [elemento1, elemento2, elemento3]
2- pop: [elemento1, elemento2]
3- peek: elemento2
4- empty: false
BUILD SUCCESSFUL (total time: 0 seconds)

09/03/2022
Contenido
lista

09/03/2022
java.util Interface Queue<E>
• Java provides a queue interface and several implementations
• boolean add(E e)
– Inserts the specified element into this queue if it is possible to do so
immediately without violating capacity restrictions, returning true upon
success and throwing an IllegalStateException if no space is currently
available.
• E element()
– Retrieves, but does not remove, the head of this queue.
• boolean offer(E e)
– Inserts the specified element into this queue if it is possible to do so
immediately without violating capacity restrictions.
• E peek()
– Retrieves, but does not remove, the head of this queue, or returns null if
this queue is empty.
• E poll()
– Retrieves and removes the head of this queue, or returns null if this queue
is empty.
• E remove()
– Retrieves and removes the head of this queue.

09/03/2022
Java Queue Implementations (1)
• Dado que Queue es una interfaz, debe crear una instancia de
una implementación concreta de la interfaz para poder usarla.
Puede elegir entre las siguientes implementaciones de cola
en la API de colecciones de Java:
– java.util.LinkedList
– java.util.PriorityQueue
• LinkedList es una implementación de cola bastante
estándar.
– Los elementos de la cola se almacenan internamente en una
estructura de datos de lista vinculada estándar.
– Esto hace que sea más rápido insertar elementos al final (cola)
de la lista y eliminar elementos del principio (encabezado) de la
lista.
• PriorityQueue almacena sus elementos internamente de
acuerdo con su orden natural (si implementan Comparable),
o de acuerdo con un Comparator pasado a
PriorityQueue.

09/03/2022
Java Queue Implementations (2)
• A continuación, se muestran algunos ejemplos de
cómo crear una instancia de cola:
• En la mayoría de las implementaciones de cola, el
principio y el final de la cola se encuentran en
extremos opuestos. Sin embargo, es posible
implementar la interfaz de cola de modo que la
cabeza y la cola de la cola estén en el mismo
extremo. En ese caso, tendrías una pila.
Queue queueA = new LinkedList();
Queue queueB = new PriorityQueue();

09/03/2022
Generic Queue
• De forma predeterminada, puede poner cualquier objeto en una
cola, pero desde Java 5, Java Generics permite limitar los tipos de
objetos que puede insertar en una cola. Aquí hay un ejemplo:
• Esta cola ahora solo puede tener instancias de MyObject insertadas
en ella. A continuación, puede acceder e iterar sus elementos sin
convertirlos. Así es como se ve:
Queue<MyObject> queue = new LinkedList<MyObject>();
Queue<MyObject> queue = new LinkedList<MyObject>();
MyObject myObject = queue.remove();
for(MyObject anObject : queue){
//do someting to anObject...
}
Observe cómo no se necesita conversión en la primera línea y cómo el bucle for-each
puede convertir cada elemento de la cola directamente en una instancia de MyObject.
Esto es posible porque la cola se creó con MyObject como tipo genérico.

09/03/2022
Add Element to Queue
• La interfaz de la cola de Java contiene dos métodos que
puede utilizar para agregar elementos a una cola. Estos
métodos son el método add () y el método offer ().
• Estos dos métodos agregan un elemento al final de la cola.
• Los métodos add () y offer () difieren en cómo se comportan
si la cola está llena, por lo que no se pueden agregar más
elementos.
• El método add () arroja una excepción en ese caso, mientras
que el método offer () solo devuelve falso.
• Aquí hay dos ejemplos de cómo agregar elementos a una
cola de Java a través de sus métodos add () y offer ():
Queue<String> queue = new LinkedList<>();
queue.add("element 1");
queue.offer("element 2");

09/03/2022
Take Element From Queue
• Para tomar un elemento de una cola de Java, puede llamar a
su método poll () o remove (). Ambos eliminan el primer
elemento de la cola.
• Se diferencian en cómo se comportan si la cola está vacía.
• El método poll () devuelve un valor nulo si la cola está vacía.
• El método remove () genera una excepción si la cola está
vacía.
• Aquí hay dos ejemplos de cómo tomar un elemento de una
cola de Java usando sus métodos poll () y remove ():
String element1 = queue.poll();
String element2 = queue.remove();

09/03/2022
Peek at the Queue (1)
• Puede echar un vistazo al elemento al principio de una cola
sin sacar el elemento de la cola. Esto se hace a través de los
métodos element () o peek ().
• El método element () devuelve el primer elemento de la cola.
Si la Cola está vacía, el método element () arroja una
NoSuchElementException.
• A continuación, se muestra un ejemplo de cómo mirar el
primer elemento de una cola de Java utilizando el método
element ():
String firstElement = queue.element();

09/03/2022
Peek at the Queue (2)
• El método peek () funciona como el método element ()
excepto que no lanza una excepción si la Cola está
vacía. En su lugar, solo devuelve nulo.
• A continuación, se muestra un ejemplo de cómo mirar el
primer elemento de una cola utilizando el método peek ():
String firstElement = queue.peek();

09/03/2022
Remove Element From Queue
• Para eliminar elementos de una cola de Java,
llame al método remove (). Este método elimina el
elemento al principio de la cola.
• A continuación, se muestra un ejemplo de cómo
eliminar un elemento de una cola de Java:
String removedElement = queue.remove();

09/03/2022
Remove All Elements From Queue
• Puede eliminar todos los elementos de una cola de Java
utilizando su método clear ().
• El método clear () en realidad se hereda de la interfaz
Collection.
• Aquí hay un ejemplo de cómo eliminar todos los elementos
de una cola de Java a través de su método clear ():
queue.clear();

09/03/2022
Get Queue Size
• Puede leer la cantidad de elementos almacenados
en una cola de Java a través de su método size ().
• Aquí hay un ejemplo de cómo obtener el tamaño
de una cola de Java a través de su método size ():
int size = queue.size();

09/03/2022
Check if Queue Contains Element
• Puede comprobar si una cola de Java contiene un
determinado elemento a través de su método contains ().
• El método contains () devolverá verdadero si la cola contiene
el elemento dado, y falso si no.
• El método contains () en realidad se hereda de la interfaz
Collection, pero en la práctica eso no importa.
• A continuación, se muestran dos ejemplos de comprobación
de si una cola de Java contiene un elemento determinado:
queue.add("Mazda");
boolean containsMazda = queue.contains("Mazda");
boolean containsHonda = queue.contains("Honda");

09/03/2022
Iterate All Elements in Queue
• También puede iterar todos los elementos de una cola
de Java, en lugar de solo procesar uno a la vez.
• A continuación, se muestra un ejemplo de iteración de
todos los elementos en una cola de Java:
//access via Iterator
Iterator<String> iterator = queue.iterator();
while(iterator.hasNext(){
String element = iterator.next();
}
//access via new for-loop
for(String element : queue) {
//do something with each element
}
Cuando se itera una cola a
través de su iterador o
mediante el bucle for-each
(que también usa el
iterador detrás de la
escena), la secuencia en la
que se iteran los elementos
depende de la
implementación de la cola.

09/03/2022
java.util Interface Deque<E>
• Java 6 now has a Deque interface
• There are 12 methods:
– Add, remove, or examine an element...
– ...at the head or the tail of the queue...
– ...and either throw an exception, or return a special value
(null or false) if the operation fails

09/03/2022
Estructuras de datos lineales
(listas)
Unidad 3
Final de la unidad

ED Unidad 3: Estructuras de datos lineales (listas)

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a ED Unidad 3: Estructuras de datos lineales (listas)

Similar a ED Unidad 3: Estructuras de datos lineales (listas) (20)

Más de Franklin Parrales Bravo

Más de Franklin Parrales Bravo (20)

ED Unidad 3: Estructuras de datos lineales (listas)