Tema 8- Implementación de Pila, Cola y

Lista con Punto de Interés

Índice general:
Tema 8- Implementación de Pila, 1. Representación Eficaz de una EDA Lineal
Cola y Lista con Punto de Interés 2. Implementación de Pila: La Clase ArrayPila
3. Implementación de Cola: La Clase ArrayCola
4. I l
Implementación
ió d
de Li
Lista Con
C Punto
P de
d Interés:
I é LaL Clase
Cl
LEGListaConPI
Germán Moltó
Escuela Técnica Superior de Ingeniería Informática
Uni ersidad Politécnica de Valencia
Universidad

1 2

Representación Eficaz de una EDA

Objetivos y Bibliografía Lineal
 Desarrollar las implementaciones más eficientes de las  Las implementaciones de Pila, Cola y Lista deben permitir que
Estructuras de Datos lineales Pila, Cola y Lista con Punto sus operaciones básicas se ejecuten en tiempo constante.
constante
 Tiempo constante: Independiente del número de elementos de la EDA.
de Interés.
 La clase ArrayPila como implementación de la interfaz Pila.
 Así, los recorridos y búsquedas simples tendrán coste
 La clase ArrayCola como implementación de la interfaz Cola.
temporal acotado por el número de elementos de la EDA:
 L clase
La l LEGListaConPI
LEGLi C PI como implementación
i l ió d de lla iinterfaz
f  Lineal (o proporcional) con el número de elementos de la EDA.
ListaConPI.
 La implementación de los métodos depende de la
 Bibliografía Principal: representación de la colección de datos:
 Capítulo 15 del libro de M
M.A.
A Weiss: “Estructuras
Estructuras de Datos en  Representación
p contigua:
g Arrayy
Java”. Adisson-Wesley, 2000.  Representación enlazada: Lista Enlazada Genérica

3 4
 Claves para implementar una EDA Implementación de Pila: La Clase
lineal ArrayPila
1. Inicialmente, representamos los datos de la EDA sobre un array de  Una Pila es una colección homogénea de public interface Pila<E> {
CAPACIDAD POR DEFECTO componentes.
CAPACIDAD_POR_DEFECTO datos que sólo se puede gestionar void apilar(E x);
E desapilar();
2. Si la EDA requiere alguna forma de acceso especial (por ejemplo accediendo secuencialmente al dato que E tope();
FIFO o LIFO),
LIFO) definir nuevos atributos que los representen para ocupa el Punto de Interés,
Interés siguiendo un b l
boolean esVacia();
V i ()
implementar el acceso eficazmente. criterio LIFO (Last In First Out), esto es, }
3. Analizar el coste de cada una de las operaciones de la interfaz accediendo al dato que ocupa el tope de
implementada. la pila, es decir, el último que se insertó.
 Si alguna operación requiere desplazamiento de datos en la y
• La clase ArrayPila implementa
p el interfaz Pila.
representación
t ió interna,
i t se descarta
d t la
l representación
t ió como un
• Atributos principales:
array.
• Un array para almacenar los elementos de la Pila.
4
4. Ensayar una implementación del interfaz con una representación • Una
U capacidad
id d iinicial
i i l para ell vector.
t
basada en Lista Enlazada. • Un marcador al tope de la pila (la posición en el vector del último
elemento insertado), inicialmente valdrá -1.

5 6

Esquema de Implementación de Pila Clase ArrayPila (1/3)

package librerias.estructurasDeDatos.lineales;
 Pila en la qque se han insertado, por
p este órden, los import librerias.estructurasDeDatos.modelos.
librerias estructurasDeDatos modelos *;;
elementos A, B, C y D public class ArrayPila<E> implements Pila<E> {
 Visión desde el punto de vista del modelo: protected E elArray[];
protected int tope;
D tope protected static final int CAPACIDAD_POR_DEFECTO = 200;
C
B @SuppressWarnings("unchecked")

A
public ArrayPila () {
elArray=y (E[])
( []) new Object[CAPACIDAD
j [ _POR_DEFECTO]; ]
• Punto de vista de la implementación: tope = -1;
}
A B C D elArray
lA public void apilar(E x) {
if ( tope + 1 == elArray.length) duplicarArray();
tope++; elArray[tope] = x; ¿Qué ocurre si se trata de apilar un nuevo
tope } elemento
l t y elArray
lA está
tá completo?
l t ?

7 8
Clase ArrayPila (2/3) Clase ArrayPila (3/3)
public E desapilar() {
public String toString() {
E elUltimo = elArray[tope]; ¿Qué ocurre si se invoca a String res = "";
tope--; desapilar y elArray está vacío?
return elUltimo; for (int i = tope; i >= 0; i--) res += elArray[i] +"\n";
} return res;
}
public E tope() { @SuppressWarnings( unchecked )
@SuppressWarnings("unchecked")
return elArray[tope]; private void duplicarArray() {
} E nuevoArray[]
y[] = ((E[])
[]) new Object[elArray.length*2];
j [ y g ]
for ( int i = 0; i <= tope; i++ ) nuevoArray[i] = elArray[i];
public boolean esVacia() { elArray = nuevoArray;
return ( tope == -11 ); }}
}
• El método toString() muestra los elementos en orden inverso al que fueron
insertados
d en lal Pila,
P l es decir,
d ell orden
d en ell que serían
í desapilados.
d l d
9 10

Implementación de Cola: La Clase

Sobre la Implementación de Pila ArrayCola
 La especificación de Pila NO indica el número máximo de elementos  Una Cola es una colección homogenea public interface Cola<E> {
que puede albergar la EDA. de elementos que solo permite void encolar(E x);
 La implementación debe gestionarlo adecuadamente, de manera
acceder secuencialmente al dato que E desencolar();
t
transparentet all usuario
i ((método
ét d d
duplicarArray).
li A )
ocupa el punto de interés siguiendo un Epprimero()
()
criterio FIFO (First In First Out), es boolean esVacia();
 Alternativamente se podría permitir que el usuario indique el máximo decir, el primer elemento que fue }
número de elementos de la Pila.
Pila insertado es el primero en ser
 Sin embargo, la estrategia original permite utilizar la Pila con un número de atendido.
elementos no conocido a priori.
• La clase ArrayCola implementa el interfaz Cola.
Cola
public ArrayPila(int n){ • Atributos principales:
elArray= (E[]) new Object[n]; • Un array para almacenar los elementos de la Cola (Object).
tope = -1; • Una capacidad inicial para el vector.
} ¿Qué coste tienen las operaciones • Un marcador al elemento primero de la Cola
i l
implementadas?
t d ? • Un marcador al último elemento de la Cola (fin)
11 12
Esquema de Implementación de Cola Esquema de Implementación de Cola
(1/2) (2/2)
 Problemas:  Dos estados del vector representando a la misma Cola.
A B C D
 Si se fija la posición de primero (Como en Pila)  Operación C D A B
desapilar() con coste lineal por mantener contigüidad.
primero
p fin
 L posición
La ó másá alta
l del
d l vector limita
l la
l posición
ó del
d l último
úl fin primero

dato de la Cola.  Mantenemos el tamaño de la Cola para diferenciar entre Cola

 S l ió
Solución: vacía y Cola llena (primero es el siguiente elemento a fin).
 Consideramos el array como una estructura circular. C D E F A B

 No existe el final de la estructura.

estructura
 La posición siguiente a la última es la primera. fin primero

 Implementación usando un vector e índices al  La circularidad se implementa

p mediante el método incrementa
que nos permitirá recorrer la estructura elemento a elemento.
principio y al final de la Cola A C F G
 Cuando el valor del parámetro es el máximo, el siguiente vale 0,
primero fin volviendo al inicio de la estructura.
13 14

La Clase ArrayCola (1/4) La Clase ArrayCola (2/4)

package librerias.estructurasDeDatos.lineales; public void encolar(E x){
i
import lib i
librerias.estructurasDeDatos.modelos.*;
D D d l * if ( tallaActual == elArray.length ) duplicarArray();
public class ArrayCola<E> implements Cola<E> { fin = incrementa(fin);
protected E elArray[]; elArray[fin] = x;
protected int fin, primero, tallaActual;
tallaActual++;
protected static final int CAPACIDAD_POR_DEFECTO
p _ _ = 200;
}
@SuppressWarnings("unchecked") public E desencolar(){
public ArrayCola(){ E elPrimer
elPrimero = elArray[primero];
elArra [ rimer ];
elArray = (E[]) new Object[CAPACIDAD_POR_DEFECTO]; primero = incrementa(primero);
tallaActual = 0;
tallaActual ;
tallaActual--;
primero = 0;
return elPrimero;
fin = -1;
} }
15 16
 La Clase ArrayCola (3/4) La Clase ArrayCola (4/4)
public E primero() { public String toString() { ¿Cómo se implementaría el
S
String res = "";
"" método toString?
return elArray[primero]; int aux = primero;
} for ( int i = 0; i < tallaActual; i++, aux = incrementa(aux)
( ))
res += elArray[aux] + " ";
public boolean esVacia(){ return res;
return ( tallaActual == 0 ); }
@SuppressWarnings("unchecked")
} private void duplicarArray() {
private int incrementa(int indice) { E nuevo[] = (E[]) new Object[elArray.length*2];
Object[elArray length*2];
for (int i = 0; i < tallaActual; i++ , primero = incrementa(primero) )
if ( ++indice == elArray.length) indice = 0; nuevo[i] = elArray[primero];
return indice;
d elArray = nuevo;
primero = 0;
} fin = tallaActual - 1;;
}}
17 18

Implementación de Lista Con Punto de Detalles de la Implementación

¿Por qué se utiliza esta
Interés: La Clase LEGListaConPI LEGListaConPI estrategia??

public interface ListaConPI<E> {

 Una Lista con Punto de Interés void insertar(E x);  El ppunto de interés se representa
p como una referencia al
es una colección homogénea de void eliminar(); objeto NodoLEG<E> anterior al que debe ser accedido.
datos que solo se puede void inicio();
void fin();
manipular
l accediendo
d d void siguiente(); 1 3 0
1 3 0

secuencialmente al dato que E recuperar();

ocupa el punto de interés.
interés ()
boolean esFin();
boolean esVacia(); PI
ant Implementación
} Modelo
 Caso especial:
C i l El primer
i elemento
l t NO ti
tiene un elemento
l t
• La clase LEGListaConPI implementa el interfaz ListaConPI.
anterior.
• Atributos principales:
• Una Lista Enlazada representada por una referencia al primer  Simulado
Sim lad mediante unn nodo
n d ficticio
fictici anteri
anteriorr al primer
rimer nodo.
n d
objeto NodoLEG<E>.  Esta solución simplifica los métodos de inserción y borrado.
• Referencia al último nodo de la lista ((eficiencia ppor la operación
p  La referencia al primer nodo NUNCA será modificada.
modificada
fin()).
19 20
 Detalles de la Implementación
LEGListaConPI La Clase LEGListaConPI (1/3)
 Lista Vacía: package librerias.estructurasDeDatos.lineales;
null
u
i
importt librerias.estructurasDeDatos.modelos.*;
lib i t t D D t d l *
public class LEGListaConPI<E> implements ListaConPI<E> {
protected NodoLEG<E> pri, pri ant,
ant ult;
PI pri ant ult
Modelo Implementación public LEGListaConPI(){
 Lista con Elementos: pri = ult = ant = new NodoLEG<E>(null);
}
null 1 3 0 public void inicio(){ ant = pri; }
1 3 0
public void fin(){ ant = ult;}
public void siguiente(){ ant = ant.siguiente; }
PI
pri ant ult public boolean esFin(){ return (ant == ult); }
Modelo
Implementación public boolean esVacia(){ return (pri == ult); }
21 22

La Clase LEGListaConPI (2/3) La Clase LEGListaConPI (3/3)

public E recuperar(){ public String toString() {
return antant.siguiente.dato;
siguiente dato; String res;
} NodoLEG<E> aux = pri.siguiente;
public void insertar(E x) { while ( aux != null ) {
NodoLEG<E> nuevo = new NodoLEG<E>(x); res += " " + aux.dato.toString();
nuevo.siguiente = ant.siguiente; aux = aux.siguiente;
ant siguiente = nuevo;
ant.siguiente }
if ( ant == ult) ult = nuevo; res += "\n";
ant = ant.siguiente; ¿Qué ocurre si se invoca el return res; ¿Cómo se implementaría el
método recuperar y el P.I.
PI está método toString?
} }
situado tras el último elemento?
public void eliminar(){ }// Fin de la clase LEGListaConPI
if ( ant.siguiente
ant siguiente == ult ) ult = ant;
ant.siguiente = ant.siguiente.siguiente;
}

23 24
Implementaciones Alternativas de Pila y
Cola La clase ArrayDequePila
 Es posible implementar los modelos de Pila y de Cola aprovechando la public class ArrayDequePila<E> extends ArrayDeque<E> implements
funcionalidad ya existente en Java.
Java Pila<E>
 En Java Platform SE 6 aparece la interfaz Deque (double ended queue) que {
permite:
public
bli ArrayDequePila()
A D Pil () { super();}
() }
 Inserción y borrado de elementos tanto al principio como al final de la
estructura.
 NO permite acceso indexado a la estructura (solo en ambos extremos).
extremos) public void apilar(E x) { push(x);}
 Permite utilizar la estructura para acceso FIFO (como una Cola) y para public E desapilar() { return pop(); }
acceso LIFO (como una Pila). public E tope() { return peek(); }
 La clase ArrayDeque proporciona la implementación de la interfaz, utilizando public boolean esVacia() { return (size() == 0); }
un array como mecanismo de almacenamiento. }
 Operaciones
O i con coste constante amortizado.
i d

25 26

La Clase ArrayDequeCola
public class ArrayDequeCola<E> extends ArrayDeque<E> implements
Cola<E>
{
public ArrayDequeCola() { super();}
public void encolar(E x) {addLast(x); }
public E desencolar() { return pollFirst(); }
public E primero() { return peekFirst(); }
public boolean esVacia() {
return (size() == 0);
}
}

27