Tema 8- Implementacin de Pila, Cola y

Lista con Punto de Inters

Tema 8- Implementacin de Pila,

Cola y Lista con Punto de Inters

ndice general:
1.
Representacin Eficaz de una EDA Lineal
2.
Implementacin de Pila: La Clase ArrayPila
3.
Implementacin de Cola: La Clase ArrayCola
4.
I l
Implementacin
i d
de Li
Lista Con
C Punto
P
de
d Inters:
I
La
L Clase
Cl
LEGListaConPI

Germn Molt
Escuela Tcnica Superior de Ingeniera Informtica
Uni ersidad Politcnica de Valencia
Universidad

Objetivos y Bibliografa
Desarrollar las implementaciones ms eficientes de las
Estructuras de Datos lineales Pila, Cola y Lista con Punto
de Inters.

La clase ArrayPila como implementacin de la interfaz Pila.

La clase ArrayCola como implementacin de la interfaz Cola.
L clase
La
l
LEGListaConPI
LEGLi C PI como implementacin
i l
i d
de lla iinterfaz
f
ListaConPI.

Representacin Eficaz de una EDA

Lineal
Las implementaciones de Pila, Cola y Lista deben permitir que
sus operaciones bsicas se ejecuten en tiempo constante.
constante

As, los recorridos y bsquedas simples tendrn coste

temporal acotado por el nmero de elementos de la EDA:

Bibliografa Principal:

Lineal (o proporcional) con el nmero de elementos de la EDA.

La implementacin de los mtodos depende de la

representacin de la coleccin de datos:
Representacin
p
contigua:
g Arrayy
Representacin enlazada: Lista Enlazada Genrica

Tiempo constante: Independiente del nmero de elementos de la EDA.

Captulo 15 del libro de M

M.A.
A Weiss: Estructuras
Estructuras de Datos en
Java. Adisson-Wesley, 2000.

Claves para implementar una EDA

lineal
Inicialmente, representamos los datos de la EDA sobre un array de
CAPACIDAD POR DEFECTO componentes.
CAPACIDAD_POR_DEFECTO
Si la EDA requiere alguna forma de acceso especial (por ejemplo
FIFO o LIFO),
LIFO) definir nuevos atributos que los representen para
implementar el acceso eficazmente.
Analizar el coste de cada una de las operaciones de la interfaz
implementada.

Si alguna operacin requiere desplazamiento de datos en la

representacin
t i interna,
i t
se descarta
d
t la
l representacin
t i como un
array.
Ensayar una implementacin del interfaz con una representacin
basada en Lista Enlazada.

1.
2.

3.

4
4.

Pila en la qque se han insertado, por

p este rden, los
elementos A, B, C y D
Visin desde el punto de vista del modelo:

tope

D
C

Una Pila es una coleccin homognea de

datos que slo se puede gestionar
accediendo secuencialmente al dato que
ocupa el Punto de Inters,
Inters siguiendo un
criterio LIFO (Last In First Out), esto es,
accediendo al dato que ocupa el tope de
la pila, es decir, el ltimo que se insert.

public interface Pila<E> {

void apilar(E x);
E desapilar();
E tope();
b l
boolean
esVacia();
V i ()
}

y
implementa
p
el interfaz Pila.
La clase ArrayPila
Atributos principales:
Un array para almacenar los elementos de la Pila.
Una
U capacidad
id d iinicial
i i l para ell vector.
t
Un marcador al tope de la pila (la posicin en el vector del ltimo
elemento insertado), inicialmente valdr -1.

Punto de vista de la implementacin:

A

Clase ArrayPila (1/3)

package librerias.estructurasDeDatos.lineales;
import librerias.estructurasDeDatos.modelos.
librerias estructurasDeDatos modelos *;;
public class ArrayPila<E> implements Pila<E> {
protected E elArray[];
protected int tope;
protected static final int CAPACIDAD_POR_DEFECTO = 200;
@SuppressWarnings("unchecked")

tope
7

Esquema de Implementacin de Pila

Implementacin de Pila: La Clase

ArrayPila

elArray
lA

public ArrayPila () {
elArray=
y (E[])
( []) new Object[CAPACIDAD
j [
_POR_DEFECTO];
]
tope = -1;
}
public void apilar(E x) {
if ( tope + 1 == elArray.length) duplicarArray();
tope++; elArray[tope] = x;
Qu ocurre si se trata de apilar un nuevo
elemento
l
t y elArray
lA
est
t completo?
l t ?
}
8

Clase ArrayPila (2/3)

public E desapilar() {
E elUltimo = elArray[tope];
tope--;
return elUltimo;
}

Clase ArrayPila (3/3)

public String toString() {
Qu ocurre si se invoca a
desapilar y elArray est vaco?

String res = "";

for (int i = tope; i >= 0; i--) res += elArray[i] +"\n";
return res;
}

public E tope() {
return elArray[tope];
}

@SuppressWarnings( unchecked )
@SuppressWarnings("unchecked")

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() {

return ( tope == -11 );
}

elArray = nuevoArray;
}}
El mtodo toString() muestra los elementos en orden inverso al que fueron
insertados
d en la
l Pila,
P l es decir,
d
ell orden
d en ell que seran
desapilados.
d
l d

10

Implementacin de Cola: La Clase

ArrayCola

Sobre la Implementacin de Pila

La especificacin de Pila NO indica el nmero mximo de elementos

que puede albergar la EDA.
La implementacin debe gestionarlo adecuadamente, de manera
t
transparente
t all usuario
i ((mtodo
t d d
duplicarArray).
li A
)
Alternativamente se podra permitir que el usuario indique el mximo
nmero de elementos de la Pila.
Pila

Sin embargo, la estrategia original permite utilizar la Pila con un nmero de

elementos no conocido a priori.

public ArrayPila(int n){

elArray= (E[]) new Object[n];
tope = -1;
}
11

Una Cola es una coleccin homogenea public interface Cola<E> {

void encolar(E x);
de elementos que solo permite
E desencolar();
acceder secuencialmente al dato que
primero()
()
Ep
ocupa el punto de inters siguiendo un
boolean esVacia();
criterio FIFO (First In First Out), es
}
decir, el primer elemento que fue
insertado es el primero en ser
atendido.

La clase ArrayCola implementa el interfaz Cola.

Cola
Atributos principales:

Qu coste tienen las operaciones

i l
implementadas?
t d ?
12

Un array para almacenar los elementos de la Cola (Object).

Una capacidad inicial para el vector.
Un marcador al elemento primero de la Cola
Un marcador al ltimo elemento de la Cola (fin)

Esquema de Implementacin de Cola

(1/2)

Problemas:

Si se fija la posicin de primero (Como en Pila) Operacin

desapilar() con coste lineal por mantener contigidad.
L posicin
La
ms
alta
l del
d l vector limita
l
la
l posicin
del
d l ltimo
l
dato de la Cola.

Dos estados del vector representando a la misma Cola.

A
primero
p

S l i
Solucin:

fin

fin

No existe el final de la estructura.

estructura
La posicin siguiente a la ltima es la primera.

fin

Implementacin usando un vector e ndices al

A C F
principio y al final de la Cola
primero

fin

Cuando el valor del parmetro es el mximo, el siguiente vale 0,

volviendo al inicio de la estructura.

14

package librerias.estructurasDeDatos.lineales;
i
import
lib i
librerias.estructurasDeDatos.modelos.*;
D D
d l *
public class ArrayCola<E> implements Cola<E> {
protected E elArray[];
protected int fin, primero, tallaActual;
protected static final int CAPACIDAD_POR_DEFECTO
p
_
_
= 200;

public void encolar(E x){

if ( tallaActual == elArray.length ) duplicarArray();
fin = incrementa(fin);
elArray[fin] = x;
tallaActual++;
}
public E desencolar(){
E elPrimer
elPrimero = elArray[primero];
elArra [ rimer ];
primero = incrementa(primero);
tallaActual ;
tallaActual--;
return elPrimero;
}

15

primero

primero

La Clase ArrayCola (2/4)

public ArrayCola(){
elArray = (E[]) new Object[CAPACIDAD_POR_DEFECTO];
tallaActual = 0;
primero = 0;
fin = -1;
}

La Clase ArrayCola (1/4)

@SuppressWarnings("unchecked")

La circularidad se implementa
p
mediante el mtodo incrementa
que nos permitir recorrer la estructura elemento a elemento.

13

Mantenemos el tamao de la Cola para diferenciar entre Cola

vaca y Cola llena (primero es el siguiente elemento a fin).

Consideramos el array como una estructura circular.

Esquema de Implementacin de Cola

(2/2)

16

La Clase ArrayCola (3/4)

public E primero() {
return elArray[primero];
}
public boolean esVacia(){
return ( tallaActual == 0 );
}
private int incrementa(int indice) {
if ( ++indice == elArray.length) indice = 0;
return indice;
d
}

La Clase ArrayCola (4/4)

Cmo se implementara el
public String toString() {
mtodo toString?
S
String
res = "";
""
int aux = primero;
( ))
for ( int i = 0; i < tallaActual; i++, aux = incrementa(aux)
res += elArray[aux] + " ";
return res;
}
@SuppressWarnings("unchecked")

private void duplicarArray() {

E nuevo[] = (E[]) new Object[elArray.length*2];
Object[elArray length*2];
for (int i = 0; i < tallaActual; i++ , primero = incrementa(primero) )
nuevo[i] = elArray[primero];
elArray = nuevo;
primero = 0;
fin = tallaActual - 1;;
}}

17

18

Implementacin de Lista Con Punto de

Inters: La Clase LEGListaConPI

Una Lista con Punto de Inters

es una coleccin homognea de
datos que solo se puede
manipular
l accediendo
d d
secuencialmente al dato que
ocupa el punto de inters.
inters

public interface ListaConPI<E> {

void insertar(E x);
void eliminar();
void inicio();
void fin();
void siguiente();
E recuperar();
()
boolean esFin();
boolean esVacia();
}

La clase LEGListaConPI implementa el interfaz ListaConPI.

Atributos principales:
Una Lista Enlazada representada por una referencia al primer
objeto NodoLEG<E>.
p
Referencia al ltimo nodo de la lista ((eficiencia ppor la operacin
fin()).
19

Detalles de la Implementacin
Por qu se utiliza esta
LEGListaConPI
estrategia??

El ppunto de inters se representa

p
como una referencia al
objeto NodoLEG<E> anterior al que debe ser accedido.
1

PI

Modelo

ant

Implementacin

Caso especial:
C
i l El primer
i
elemento
l
t NO ti
tiene un elemento
l
t
anterior.

20

Simulado
Sim
lad mediante unn nodo
n d ficticio
fictici anteri
anteriorr al primer
rimer nodo.
n d
Esta solucin simplifica los mtodos de insercin y borrado.
La referencia al primer nodo NUNCA ser modificada.
modificada

Detalles de la Implementacin
LEGListaConPI

Lista Vaca:

package librerias.estructurasDeDatos.lineales;
i
import
t 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;

null
u

PI

Modelo

La Clase LEGListaConPI (1/3)

pri

ant

ult

Implementacin

Lista con Elementos:

1

PI

Modelo

null

pri

ant

ult

Implementacin

21

La Clase LEGListaConPI (2/3)

public E recuperar(){
return ant
ant.siguiente.dato;
siguiente dato;
}
public void insertar(E x) {
NodoLEG<E> nuevo = new NodoLEG<E>(x);
nuevo.siguiente = ant.siguiente;
ant siguiente = nuevo;
ant.siguiente
if ( ant == ult) ult = nuevo;
Qu ocurre si se invoca el
ant = ant.siguiente;
mtodo recuperar y el P.I.
PI est
}
situado tras el ltimo elemento?
public void eliminar(){
if ( ant.siguiente
ant siguiente == ult ) ult = ant;
ant.siguiente = ant.siguiente.siguiente;
}
23

public LEGListaConPI(){
pri = ult = ant = new NodoLEG<E>(null);
}
public void inicio(){ ant = pri; }
public void fin(){ ant = ult;}
public void siguiente(){ ant = ant.siguiente; }
public boolean esFin(){ return (ant == ult); }
public boolean esVacia(){ return (pri == ult); }
22

La Clase LEGListaConPI (3/3)

public String toString() {
String res;
NodoLEG<E> aux = pri.siguiente;
while ( aux != null ) {
res += " " + aux.dato.toString();
aux = aux.siguiente;
}
res += "\n";
return res;
}
}// Fin de la clase LEGListaConPI

24

Cmo se implementara el
mtodo toString?

Implementaciones Alternativas de Pila y

Cola

La clase ArrayDequePila

Es posible implementar los modelos de Pila y de Cola aprovechando la

funcionalidad ya existente en Java.
Java

En Java Platform SE 6 aparece la interfaz Deque (double ended queue) que

permite:
Insercin 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)

Permite utilizar la estructura para acceso FIFO (como una Cola) y para
acceso LIFO (como una Pila).

public E desapilar() { return pop(); }

La clase ArrayDeque proporciona la implementacin de la interfaz, utilizando

un array como mecanismo de almacenamiento.
Operaciones
O
i
con coste constante amortizado.
i d

25

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

public
bli ArrayDequePila()
A
D
Pil () { super();}
() }
public void apilar(E x) { push(x);}
public E tope() { return peek(); }
public boolean esVacia() { return (size() == 0); }
}

26

La Clase ArrayDequeCola

public class ArrayDequePila<E> extends ArrayDeque<E> implements

Pila<E>