2- TDA Listas

Módulo 2: Tipos de Datos basados en Listas
NAC
Modalidad de estudios: Virtual
Mg. Luis Fernando Aguas Bucheli
+593 984015184
@Aguaszoft
Laguas@uisrael.edu.ec
Zeuszoft@protonmail.com

Objetivos del encuentro:
1. Adquirir los conceptos básicos relacionados con la
programación
2. Reconocer las características de la programación
3. Conocer la historia de la progrmación
Módulo Nro. 2

Frase Motivacional
Cuando te encuentres a ti mismo al
lado de la mayoría, es tiempo de
parar y reflexionar
(Mark Twain)

NAC © aguaszoft@outlook.es 4
Definición del TDA PILA
Una pila es un caso especial de lista en la cual todas las
inserciones y supresiones tienen lugar en un extremo
determinado llamado tope.
A las pilas se les llama también listas LIFO (last-in first-out) o
listas “primero en entrar, primero en salir”.
En el TDA Pila tampoco se definen operaciones de
posicionamiento en la pila. Esto es debido a que todas las
operaciones de acceso se realizan en la misma posición, el tope
de la pila.

Operaciones del TDA PILA
TDA PILA incluye cinco operaciones:
CREA. Crea una pila vacía.
VACIA. Devuelve un valor cierto si la pila está vacía, y falso en caso
contrario.
TOPE. Devuelve el elemento situado el tope de la pila, sin extraerlo.
 PUSH. Añade un elemento a la pila, quedando éste situado en el
tope.
POP. Suprime el elemento situado en el tope de la pila.

Especificación PILA
Pila = TDA con operaciones crea, vacia, tope, push, pop.
DESCRIPCIÓN:
Los valores del TDA Pila son pilas de elementos del tipo Elemento.
Las pilas son mutables:
 Push añaden elementos en la pila respectivamente.
 Pop elimina elementos de la pila respectiva.
OPERACIONES:
crea() devuelve (P: Pila)
 efecto: Devuelve la pila vacía P

Especificación PILA
vacia(P:Pila) devuelve (booleano)
 efecto: Devuelve cierto si P es la pila vacía, y falso en caso contrario.
tope(P:Pila) devuelve (E:Elemento)
 requerimientos: La pila P es no vacía.
 efecto: Devuelve en E el elemento situado en el tope de la pila P
push(P:Pila; E:Elemento)
 modifica: P
 efecto: Añade el elemento E a la pila P, quedando éste situado en el tope.
pop(P:Pila)
 requerimientos: La pila P es no vacía.
 modifica: P
 efecto: Suprime el elemento situado en el tope de la pila

Implementaciones del TDA PILA
 Tres alternativas para implementar
el TDA PILA:
1. Implementación basada en el TDA
Lista; consiste en definir una Pila
utilizando una lista.
2. Implementación con vectores;
utiliza un arreglo para almacenar los
elementos de la Pila
3. Implementación con referencias con
representación con simple enlace.
poppush

Implementación basada en el TDA Listapackage pilaBasadaLista;
import pilaException.*;
import listaException.*;
import listaSimpleEnlazada.*;
public class Pila implements pilaInterface.Pila {
private Lista lista;
public Pila() {
lista = new Lista();
}
public boolean vacia() {
return lista.vacia();
}
public Object tope() throws PilaVaciaException {
if (vacia()) throw new PilaVaciaException();
try {
return lista.recupera(lista.primero());
} catch (ListaException e) {
System.err.println("Error interno de la Pila: "+e);
return null;
}

Implementación basada en el TDA Lista 2
public void push(Object elemento) {
try {
if (vacia()) lista.inserta(lista.fin(),elemento);
else lista.inserta(lista.primero(),elemento);
} catch (ListaVaciaException e) {
System.err.println("Error interno de la Pila");
}
}
public void pop() throws PilaVaciaException{
try {
lista.suprime(lista.primero());
System.err.println("Error interno de la Pila");
}
}
} // fin class Pila

Implementación con vectores (array)
Representación de una pila mediante un vector
0
1
a3
max-3
tope = max-3
a2
max-2
a1
max-1

Implementación con vectores (array) 2
package pilaContigua;
private static int max = 100;
private Object elementos[];
private int tope;
public Pila() {
elementos = new Object[max];
tope=max;
}
return (tope==max);
}

Implementación con vectores (array) 3
return elementos[tope];
}
tope--;
elementos[tope]=elemento;
}
tope++;
}
} // fin class Pila

Implementación con referencias
package pilaSimpleEnlazada;
class Celda {
Object elemento;
Celda sig;
}
private Celda pila;
public Pila() {
pila = null;
}
return (pila==null);
}

Implementación con referencias 2
return pila.elemento;
}
Celda aux = new Celda();
aux.elemento = elemento;
aux.sig = pila;
pila = aux;
}
pila = pila.sig;
}
} // fin class Pila

Comparación de las implementaciones
 Los criterios que se utilizaron en Listas, son también
válidos para las implementaciones de pilas.
 La elección de una implementación u otra dependerá de los
requerimientos de la aplicación en la que se use.
 Es posible obtener representaciones para pilas que
permiten operaciones eficientes que se realizan en tiempos
de ejecución constantes.

Ejemplo de pilas:
Torres de Hanoi
Hanoi(origen,destino,pivote,discos):
si discos=1
moveruno(origen,destino)
en otro caso
Hanoi(origen,pivote,destino,discos-1)
moveruno(origen,destino)
Hanoi(pivote,destino,origen,discos-1)

Torres de Hanoi
Condiciones:
 5 fichas
 Ficha 1 > 2 > 3 > 4 > 5
 3 Torres
 A, B, C
 Torre A inicia con 5 fichas
 Torre B y C vacías
 Objetivo mover las fichas de A a C
 Un movimiento a la vez
 No puede ir una ficha mayor sobre una menor
 Ganador el que menor numero de movimientos realiza

Definición del TDA Cola
Una cola es un caso particular de una lista en el cual los
elementos se insertan en un extremo (el posterior o final) y se
suprimen en el otro (el anterior o frente).
Las colas se conocen también como listas FIFO (first-in first-
out) o listas primero en entrar, primero en salir.
Algunas de las operaciones de listas pierden sentido en el
TDA Cola y se definen nuevas operaciones.

Especificación
COLA
TDA con operaciones crea, vacía, primero, inserta, suprime.
 DESCRIPCIÓN:
Los valores del TDA Cola son colas de elementos del tipo
Elemento.
Las colas son dinámicas añaden y eliminan elementos en la
cola respectivamente.
OPERACIONES:
crea(Q)
efecto: Devuelve la cola vacía Q.

Especificación
vacia(Q)
efecto: Devuelve verdadero si Q es vacía y falso en caso contrario.
primero(Q, e)
requerimientos: La cola es no vacía.
efecto: Devuelve el primer elemento e de la cola Q.
inserta(Q, e)
modifica: Q.
efecto: Añade el elemento e por el extremo final de la cola Q.
suprime(Q)
requerimientos: La cola es no vacía.
modifica: Q.
efecto: Suprime el primer elemento de la cola Q.

Ejemplo : Imprimir colaimport colaInterface.*;
import colaException.*;
import java.io.*;
public class ColaUtil {
static public void imprimir(Cola cola) {
try {
Cola colaAux = duplicar(cola);
while (!colaAux.vacia()) {
Object e = colaAux.primero();
colaAux.suprime();
System.out.print(e+" ");
}
System.out.println();
} catch (ColaException e) {
System.err.println("Error en el uso de la Cola: "+e);
}
} // fin imprimir()

Ejemplo: duplicar colastatic public Cola duplicar(Cola cola) {
try {
Cola cola2 = (Cola)cola.getClass().newInstance();
Cola colaAux = (Cola)cola.getClass().newInstance();
while (!cola.vacia()) {
Object e = cola.primero();
cola.suprime();
cola2.inserta(e);
colaAux.inserta(e);
}
colaAux.suprime();
cola.inserta(e);
}
return cola2;
} catch (Exception e) { System.err.println(e); }
return null;
} // fin duplicar()

Ejemplo: concatenar colasstatic public Cola concatenar(Cola cola1, Cola cola2) {
try {
Cola cola3 = (Cola)cola1.getClass().newInstance();
Cola colaAux = duplicar(cola1);
colaAux.suprime(); cola3.inserta(e);
}
colaAux = duplicar(cola2);
colaAux.suprime(); cola3.inserta(e);
}
return cola3;
} catch (Exception e) { System.err.println(e); }
return null;
} // fin concatenar
} // fin class ColaUtil

COLA Implementaciones
TDA COLA se puede implementar con:
Basada en el TDA Lista
Basada en vectores circulares
Basada en referencias
Basada en cursores (arreglos)
enqueue dequeue

Basada en TDA Lista 1package colaBasadaLista;
import listaException.*;
import listaSimpleEnlazada.*;
public class Cola implements colaInterface.Cola {
private Lista lista;
public Cola() {
lista = new Lista();
}
return lista.vacia();
}
public Object primero() throws ColaVaciaException {
if (vacia()) throw new ColaVaciaException();
try {
return lista.recupera(lista.primero());
System.err.println("Error interno de la Cola: "+e);
return null;
}

Basada en el TDA Lista 2
public void inserta(Object elemento) {
lista.inserta(lista.fin(),elemento);
}
public void suprime() throws ColaVaciaException{
try {
lista.suprime(lista.primero());
System.err.println("Error interno de la Cola: "+e);
}
}
} // fin class Cola

Basada en vector circular 1
public class Cola {
private int frente, post;
} // fin clase Cola
a1
a2
an
an-1
...
...
frente post

package colaVectoresCirculares;
private int frente, post;
public Cola() {
elementos = new Object[max+1];
frente = 1;
post = 0;
}
return (frente == ((post+1)%(max+1)));
}

return elementos[frente];
}
post = (post+1)%(max+1);
elementos[post]=elemento;
}
frente = (frente+1)%(max+1);
}
} // fin clase Cola

Basada en referencias 1
package colaSimpleEnlazada;
class Celda {
Object elemento;
Celda sig;
}
private Celda frente,post;
public Cola() {
frente = new Celda();
frente.sig = null;
post = frente;
}
return (frente==post);
}

Basada en referencias 2
return frente.sig.elemento;
}
post.sig = new Celda();
post = post.sig;
post.elemento = elemento;
post.sig = null;
}
frente = frente.sig;
}
} // fin clase Cola

Comparación
• Los criterios descritos en listas son también válidos para
las implementaciones de colas.
• La elección de una implementación u otra dependerá de
los requerimientos de la aplicación en la que se use.
• Es posible obtener representaciones para colas que
permiten operaciones eficientes con tiempos de ejecución
optimizados.

COLAS ESPECIALES
 Dicolas
 Las eliminaciones e inserciones pueden realizarse en
ambos extremos de la lista.
 Es como tener dos colas en una sola, cada una con su
propio sentido.
Colas de Prioridad
 Es una cola a cuyos elementos se les ha asignado una
prioridad, de forma que el orden en que los elementos
son procesados sigue las siguientes reglas:
El elemento con mayor prioridad es procesado primero.
Dos elementos con la misma prioridad son procesados según el
orden en que fueron introducidos en la cola.

Colas de Prioridad
 Existen dos métodos para la representación de
colas de prioridad:
 Tener la cola siempre ordenada de acuerdo a las
prioridades de sus elementos y
sacar cada vez el primer elemento de ésta, es decir,
el de mayor prioridad. En este caso, cuando se
introduce un elemento en la cola, debe insertarse en el
lugar correspondiente de acuerdo a su prioridad.
 Insertar los elementos siempre al final de la cola, y
cuando se va a sacar un elemento, buscar el que tiene
mayor prioridad.

Interface Colas de Prioridad
 La interface en Java del TDA Cola de Prioridad puede ser
la siguiente:
package colaPrioridadInterface;
public interface ColaPrioridad {
public boolean vacia();
public Object primero() throws ColaVaciaException;
public int primero_prioridad() throws
ColaVaciaException;
public void inserta(Object elemento, int prioridad);
public void suprime() throws ColaVaciaException;
} // fin interface ColaPrioridad

Implementación Cola de Prioridad
package colaPrioridadSimpleEnlazada;
public class ColaPrioridad implements
colaPrioridadInterface.ColaPrioridad {
class Celda {
Object elemento;
int prioridad;
Celda sig;
}
private Celda cola;
public ColaPrioridad() {
cola = new Celda();
cola.sig = null;
}

Implementación Cola de Prioridad
return (cola.sig==null);
}
return cola.sig.elemento;
}
public int primero_prioridad() throws ColaVaciaException {
return cola.sig.prioridad;
}
public int primero_prioridad() throws ColaVaciaException {
return cola.sig.prioridad;
}

Implementación Cola de Prioridadpublic void inserta(Object elemento, int prioridad) {
Celda p,q;
boolean encontrado = false;
p = cola;
while((p.sig!=null)&&(!encontrado)) {
if (p.sig.prioridad<prioridad)
encontrado = true;
else p = p.sig;
}
q = p.sig;
p.sig = new Celda();
p = p.sig;
p.elemento = elemento;
p.prioridad = prioridad;
p.sig = q;
}
public void suprime() throws ColaVaciaException {
cola = cola.sig;
}

Java Class Queue
 Constructor
Queue()
Metodos
java.lang.Object
dequeue() remueve y retorna lel item de la cabecera de la cola
Void
enqueue(java.lang.Objectitem) añade el item especificado al final de la
cola
Boolean
isEmpty() Retorna verdadero cuando la cola es vacía
Int
size() Retorna el numero de elementos que estan en la cola
java.lang.String
toString() retorna un String que representa el contenido de la cola

Aplicación
Simulación de cajas y cajeros
El modelo de simulación examinar la ocurrencia de
eventos.
Los principales objetos dinámicos son los procesos.
Los principales objetos pasivos son los recursos.
Dos parámetros importantes:
tiempo de servicio y
tiempo de llegada de los clientes.

Proceso de llegada
•Si el nº de clientes que llegan es finito o infinito
•Si se tiene uno o varios tipos de clientes
•Si se tiene uno o varios tipos de demanda distintos
•Si las llegadas son deterministicas o estocasticas
•Si la tasa de llegada depende de la longitud de la cola

Proceso del servidor - cajero
•Cuantos servidores estan disponibles al mismo tiempo
para los mismos clientes con demandas identicas.
•Si hay uno o varios tipos de servidores
•Si la tasa de servicio debe ser constante o dependiente
de las exigencias del cliente
•Si el tiempo de servicio debe ser fijo (deterministico) o
estocastico

Aplicación
Simulación cajas y colas
• Condiciones:
• Numero de cajas de 1 .. 5
• El usuario determina cuantas caja desea
• Cada caja tiempo T1 .. T5 tiempo atención
• Numero de colas de 1 .. 5
• EL usuario determina cuantas colas desea
• Arribo de clientes
• Cada cola tiempo A1 .. A5 tiempo de arribo

Aplicación
Simulación cajas y colas 2
• Aplicación
• Modo gráfico
• Condiciones anteriores
• Facilidad de uso
• Conclusiones al usuario
• Numero óptimo de cajeros
• Numero óptimo de colas

LISTAS DOBLES
• Descripción
• A una lista simplemente ligada
• Complementarla con un acceso “BACK”
• Orientación FRONT es lista normal
• Orientación BACK es lista reversa
• Utilización
• Es más óptimo para determinar elementos anterior y siguiente
• El acceso “back” permite regenerar lista
• Óptimo para orden ascendente / descendente
Front
Back

LISTAS DOBLES
• OPERACIONES:
• MAKENULL(L) Inicializa cada sentido a NULL
• INSERT(L, p, e) p referente desde Front
• DELETE(L, p) p referente desde Front
• FIRST(L) Front(L)
• END(L) Back(L)
• PRINT(L, s) s sentido de impresión
• s puede ser front o back
• REPAIR(L) reparar referencias o cursores
perdidos

LISTAS CIRCULARES
• Definición:
• No existe fin de lista
• Existe un indicador de inicio de lista
• El primer nodo es el siguiente del último
• Ejemplo:
• Atención de procesos “multitarea”
a1
a2
ai+1
ai
...
...
L1
an

LISTAS CIRCULARES
• OPERACIONES:
• MAKENULL(L) Crea lista vacía
• FIRST(L) Referencia inicio de L
• END(L) Último elemento ingresado
• INSERT(L, p, e) Posición referencial desde L
• DELETE(L,p) Posición referencial desde L
• NEXT(L,p) Posición referencial desde L
• PREVIOUS(L,p) Posición referencial desde L
• PRINT(L) Secuencia infinita de elementos
• Es necesario indicador de salida

DOBLES CIRCULARES
• Definición:
• Es la combinación de lista circular con lista doble
• Permite atención de procesos front – back
• Utilizada en S.O. Atención de CPU
• Es segura y óptima
a1
a2
ai+1
ai
...
...
L1
an

DOBLES CIRCULARES
• OPERACIONES:
• MAKENULL(L) Las referencias se inicializan en null
• FIRST(L) Referencia desde L1
• END(L) Último elemento ingresado
• INSERT(L, p, e) p considerado desde L1
• DELETE(L,p) p considerado desde L1
• PRINT(L, s) s sentido front / back
• NEXT(L, p, s)
• PREVIOUS(L, p, s)
NODO 3

2- TDA Listas

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (17)

Similar a 2- TDA Listas

Similar a 2- TDA Listas (20)

Más de Luis Fernando Aguas Bucheli

Más de Luis Fernando Aguas Bucheli (20)

Último

Último (20)

2- TDA Listas