T5 - TAD Lineales - Pilas

Estrategias
de programacin y estructuras de datos

Grado en Ingeniera Inform8ca
Grado en Tecnologas de la Informacin
Departamento de Lenguajes y Sistemas inform6cos
Tipos abstractos de
datos lineales
Pilas
Javier Vlez Reyes Jos Ignacio Mayorga Toledano

jvelez@lsi.uned.es
nmayorga@lsi.uned.es
Departamento de Lenguajes Y Sistemas InformDcos
UNED
Tipos abstractos de datos lineales. Pilas

ndice
ndice
Tipos abstractos de datos lineales
El tipo abstracto de datos Pila
Interfaz del tipo abstracto de datos Pila
Implementaciones del tipo abstracto de datos Pila
5-2
Introduccin
Implementacin dinmica
Implementacin esttica
Implementacin con Lista
Algoritmos sobre Pilas
Recorrido de los elementos de una Pila
Bsqueda de un elemento sobre una Pila
Problemas y ejercicios
Bibliografa
Javier Vlez Reyes jvelez@lsi.uned.es Jos Ignacio Mayorga Toledano nmayorga@lsi.uned .es

Obje6vos generales
Obje8vos
Conocer la interfaz del tipo abstracto de datos Pila
Aprender a implementar el TAD Pila mediante la interfaz StackIF
5-3
En versin esttica (con limitacin explcita de capacidad mxima)
En versin dinmica (sin limitacin explcita de capacidad mxima)
Utilizando una lista
Conocer los principales problemas algortmicos sobre pilas
Recorrido de los elementos de una pila
Bsqueda de un elemento sobre una pila
Practicar el diseo de funciones recursivas sobre pilas

Introduccin
Tipos abstractos de datos lineales

Los 6pos abstractos de datos lineales representan abstracciones en las que los datos son
organizados de forma secuencial. A con6nuacin se muestran los diferentes TADs que caen
dentro de esta categora y que se diferencian, esencialmente, en la forma en que se ofrecen
acceso a sus datos
I. Listas
Tema 4
Tema 5
Tipos abstractos
de datos lineales
El tipo abstracto de datos Lista representa una estructuras de datos

donde los elementos se disponen de forma secuencial y las
operaciones de insercin y extraccin se aplican por el principio,
que puede moverse recursivamente haciendo referencia a otras
sublistas
Tema 6
II. Pilas
El tipo abstracto de dato Pila representa una estructuras de datos
operaciones de insercin y extraccin se aplican por el principio
segn la poltica de acceso ltimo en entrar, primero en salir
III. Colas
El tipo abstracto de dato Cola representa una estructuras de datos
operaciones de insercin y extraccin se aplican por el final y por el
principio respectivamente de acuerdo a la poltica de primero en
entrar, primero en salir
5-4

Introduccin
El 8po abstracto de datos Pila

Las pilas son abstracciones de datos que organizan una coleccin de elementos de manera
secuencial, donde existe un nico punto de inters llamado cima por donde se realizan las
operaciones de acceso. La pol6ca de acceso indica que el l6mo elemento en entrar en una
pila es el primero en salir de ella (Last In First Out, LIFO).
Una pila es un 6po abstractos de datos que organiza una coleccin de elementos
de forma secuencial. Las operaciones de acceso se realizan por un extremo
llamado cima y la pol6ca de acceso es l6mo en entrar primero en salir (LIFO)
4
Cima
Las operaciones de
insercin y
extraccin se
realizan por un
extremo llamado
cima
5-5
3
2
1
Pila
Una pila puede imaginarse como una
estructura de datos que dispone los
mismos en secuencia uno encima de
otros de manera que siempre el ltimo
elemento en apilarse es el nico que
puede ser directamente accedido

Interfaz del 6po abstracto de datos Pila
La interfaz del 8po abstracto de datos Pila StackIF <T>

El interfaz de Pila que u6lizaremos a lo largo de este
curso, StackIF est compuesto por las operaciones que
describimos a con6nuacin
1
2
3
1
2
3
push (1)
pop ()
1
2
3
1
2
3
5-6
Insertar
La operacin push inserta un elemento encima
de la cima de manera que el elemento
insertado pasa a ser la nueva cima
Extraer
2
3
La operacin pop extrae el elemento en la cima

de la pila de manera que el elemento en la
cima pasa a ser el de siguiente en la pila
Es vaca
1
2
3
falso
cima
Todas las operaciones de una pila se atacan
por la cima. Este mtodo devuelve el elemento
en la cima sin extraerlo
cierto
Este predicado indica si la pila no contiene

ningn elemento. Semnticamente equivale a
preguntar si el nmero de elementos es 0 (ver
despus)
public interface StackIF <T>

{
/**
* Devuelve la cima de la pila.
* @return la cima de la pila.
*/
public T getTop ();

/**
* Inserta un elemento a la pida.
* @param element El elemento a ser aadido.
* @return la pila incluyendo el elemento.
*/
public StackIF<T> push (T element);

/**
* Extrae de la pila el elemento en la cima.
* @return la pila excluyendo la cabeza.
*/
public StackIF<T> pop ();

/**
* Devuelve cierto si la pila esta vacia.
* @return cierto si la pila esta vacia.
*/
public boolean isEmpty ();


Interfaz del 6po abstracto de datos Pila
La interfaz del 8po abstracto de datos Pila StackIF <T>

El interfaz de Pila que u6lizaremos a lo largo de este
curso, StackIF est compuesto por las operaciones que
describimos a con6nuacin
Est llena
1
2
3
2
3
cierto
falso
1
2
3
1
2
3
getLength ()
contains (3)
cierto
contains (7)
falso
1
2
3
5-7
En implementaciones con capacidad mxima

limitada tiene sentido preguntar si una pila ha
alcanzado el nmero mximo de elementos
que puede albergar
Longitud
La longitud de una pila devuelve el nmero de
elementos que esta contiene. Si la pila esta
vaca devuelve 0. Si esta llena devuelve la
capacidad de la pila
Bsqueda
La operacin contains busca un elemento en la
pila e indica si est contenido dentro de la
misma
Recorrido
1
2
3
El recorrido de una pila devuelve un iterador

que permite visitar todos los elementos de la
pila segn aparecen desde la cima hasta la
base de la misma
/**
* Devuelve cierto si la pila esta llena.
* @return cierto si la pila esta llena.
*/
public boolean isFull();

/**
* Devuelve el numero de elementos de la pila.
* @return el numero de elementos de la pila.
*/
public int getLength ();

/**
* Devuelve cierto si la pila contiene el elemento.
* @param element El elemento buscado.
* @return cierto si la pila contiene el elemento.
*/
public boolean contains (T element);

/**
* Devuelve un iterador para la pila.
* @return un iterador para la pila.
*/
public IteratorIF<T> getIterator ();

}

Implementacin del 6po abstracto de datos Pila
Implementacin del 8po abstracto de datos Pila StackIF <T>

Existen varias estrategias para implementar pilas que responden al interfaz StackIF anterior.
En general, stas se dividen en implementaciones dinmicas, que ar6culan pilas de
capacidad indenida e implementaciones est6cas, con una capacidad mxima limitada y
establecida como parmetro. A con6nuacin presentamos varias implementaciones
Implementacin dinmica basada en elemento y siguiente

Segn esta estrategia de implementacin, una pila est formada por un atributo que
representa la cima y otro que es una referencia a una pila y representa el resto de la pila.
De esta manera una pila es una coleccin encadenada de pares (elemento, siguiente)
Pila
Cima y siguiente
Ul8mo, elemento fantasma
Cada objeto Pila contiene un atributo para

representar el elemento en la cima de la pila y
un atributo del tipo definido StackIF que
representa una referencia al resto de
elementos debajo de la cima
5-8
La pila es una secuencia

de pares (elemento,
siguiente) acabada en un
par fantasma
Aunque en otras implementaciones el valor del

ltimo objeto se aprovecha para incluir un
ltimo elemento aqu el final se marca con un
objeto fantasma con ambos atributos a null.
Esto evita excepciones de puntero a null y
simplifica la algoritmia con la pila a un nico
caso base isEmpty ()


public class StackDynamic <T> implements StackIF<T> *
{
private T element;
private StackDynamic<T> next;

public StackDynamic ()
{
element = null;
next = null;
}

public StackDynamic (StackIF<T> stack)
{
this ();
if (stack != null)
if (!stack.isEmpty ())
{
element = stack.getTop ();
next = new StackDynamic<T> (stack.pop ());
stack.push (element);
}
}

public StackDynamic (ListIF<T> list)
{
this ();
if (list != null)
if (!list.isEmpty () {
element = list.getFirst ();
next = new StackDynamic<T> (list.getTail ());
}
}
5-9
@Override
public T getTop ()
{
return element;
}

@Override
public StackIF<T> push (T element)
{
if (element != null) {
StackDynamic<T> stack = new StackDynamic<T> ();
stack.element = this.element;
stack.next = this.next;
this.element = element;
this.next = stack;
}
return this;
}

@Override
public StackIF<T> pop ()
{
if (!isEmpty ()) {
element = next.element;
next = next.next;
}
return this;
}

* Los comentarios de las cabeceras se

han omitido por cuestiones de espacio


@Override
public boolean isEmpty ()
{
return element == null &&
next == null;
}

@Override
public boolean isFull()
{
return false;
}

@Override
public int getLength ()
{
if (isEmpty ()) return 0;
return 1 + next.getLength ();
}

@Override
public boolean contains (T element)
{
if (isEmpty ()) return false;
else return this.element.equals (element) ||
next.contains (element);
}
@Override
public IteratorIF<T> getIterator ()
{
StackIF<T> handler = new StackDynamic<T> (this);
return new StackIterator<T> (handler);
}

@Override
public int hashCode ()
{
return 31 * ((element == null) ? 0 : element.hashCode ()) +
((next == null) ? 0 : next.hashCode ());
}

@SuppressWarnings("unchecked")
@Override
public boolean equals (Object o) {
...
}

@Override
public String toString () {
...
}
}

5 - 10


establecida como parmetro.
Implementacin est8ca basada en array

Segn esta estrategia de implementacin, una pila est cons6tuida por un array de
capacidad limitada y especicada mediante un parmetro y un ndice que apunta a la
cima de la pila. La pila empieza por la posicin 0 y avanza hacia posiciones crecientes
Pila
La pila est formada por los
elementos que van desde la
posicin 0 hasta cima
Extraer
Extraer mueve la cima de la pila
una posicin hacia atrs con lo
que la posicin anterior pasa a
ser la nueva cima. Cima == 0
indica una pila vaca luego esa
posicin se desaprovecha
5 - 11
Basura
Capacidad = 10
1 2 3 3 7 0 0 0 0
cima
Este ndice apunta siempre
al elemento que se
encuentra en la cima de la
pila. El ndice comienza en
0 y llega hasta capacidad1
para valores de la pila
El resto de elementos del

array que no pertenecen a la
pila son basura, resultado
del trabajo con el tipo
Insertar
Las inserciones mueven la cima
una posicin hacia adelante e
insertan el elemento. Si cima
llega a valer capacidad - 1 el
array est lleno y no se puede
insertar


public class StackStatic <T> implements StackIF<T> *
{
private Object[] elements;
private int capacity;
private int top;

public StackStatic (int capacity)
{
this.elements = new Object[capacity];
this.capacity = capacity;
this.top = -1;
}

public StackStatic (StackIF<T> stack)
{
if (stack != null) {
this.capacity = stack.getLength ();
this.elements = new Object[this.capacity];
this.top = -1;

for (int i = capacity - 1; i >= 0; i--) {
T element = stack.getTop ();
elements [i] = element;
stack.pop ();
top ++;
}
for (int i = 0; i <= capacity - 1; i++) {
T element = (T) elements [i];
stack.push (element);
}
}
}
5 - 12
public StackStatic (ListIF<T> list)

{
if (list != null) {
this.capacity = list.getLength ();
this.elements = new Object[this.capacity];
this.top = -1;

ListIF<T> aList = list;
for (int index = 0; index < list.getLength (); index++) {
this.elements [index] = aList.getFirst ();
aList = list.getTail ();
}
}
}

public T getTop ()
{
if (isEmpty ()) return null;
return (T) elements [top];
}

{
if (element != null)
if (!isFull ()) {
top = top + 1;
elements [top] = element;
}
return this;
}




@Override
{
if (!isEmpty ()) {
top = top - 1;
}
return this;
}

@Override
{
return top == -1;
}

@Override
{
return top == (capacity 1);
}

@Override
{
return top + 1;
}

@Override
{
IteratorIF<T> stackIt = this.getIterator ();
boolean found = false;
while (!found && stackIt.hasNext ()) {
T anElement = stackIt.getNext ();
found = anElement.equals (element);
}
return found;
}

@Override
{
StackIF<T> handler = new StackStatic<T> (this, capacity);
}

@Override
public int hashCode () {...}

@Override
public boolean equals (Object o) {...}

@Override
public String toString () {...}
}

5 - 13


establecida como parmetro.
Implementacin basada en lista

Dado que las implementaciones de pilas que hemos visto son bastante similares a las de
listas, es posible implementar una pila a par6r de una lista. El carcter est6co o
dinmico de la implementacin depender del 6po de implementacin de lista u6lizada
Resto es resto de pila
El resto de elementos de la lista
corresponde con la subpila que hay
debajo de la cima
Primero es cima
El primer elemento
de una lista se
corresponde con la
cima de la pila
2 3 4 5 6 7 8 9
ListIF
Pila
La pila se implementa a partir de cualquier implementacin del
TAD Lista con interfaz ListIF. La operacin de insertar se
implementa con la insercin en la lista y la de extraccin con la
operacin de obtener resto de la lista
5 - 14


Dado que las implementaciones de pilas que hemos visto son bastante similares a las de
listas, es posible implementar una pila a par6r de una lista. El carcter est6co o
dinmico de la implementacin depender del 6po de implementacin de lista u6lizada
public class StackList <T> implements StackIF<T> *
{
private ListIF<T> list;

public StackList ()
{
this.list = new ListDynamic<T> ();
}

public StackList (StackIF<T> stack) {...}

public StackList (ListIF<T> list)
{
this.list = new ListDynamic<T> (list);
}

@Override
public T getTop ()
{
return list.getFirst ();
}

@Override
{
list.insert (element);
return this;
}

@Override
{
list = list.getTail ();
return this;
}

@Override
{
return list.isEmpty ();
}

@Override
{
return list.isFull ();
}

@Override
{
return list.getLength ();
}

@Override
{
return list.contains (element);
}
*
Los comentarios de las cabeceras se

5 - 15


Dado que las implementaciones de pilas que hemos visto son bastante similares a las de listas,
es posible implementar una pila a partir de una lista. El carcter esttico o dinmico de la
implementacin depender del tipo de implementacin de lista utilizada
@Override
{
StackIF<T> handler = new StackList<T> (list);
}

@Override
public int hashCode ()
{
return 31 * ((list == null) ? 0 : list.hashCode ());
}

@Override
public boolean equals (Object o)
{
if (o == this) return true;
if (o == null) return false;

if (o.getClass () != this.getClass ()) return false;
else {
StackList<T> s = (StackList<T>) o;
return s.list.equals (list);
}
}
@Override
public String toString ()
{
StringBuffer buff = new StringBuffer ();
buff.append ("StackList - [");

IteratorIF<T> stackIt = getIterator ();
while (stackIt.hasNext ()) {
T element = stackIt.getNext ();
buff.append (element);
if (stackIt.hasNext ())
buff.append (", ");
}

buff.append ("]");
return buff.toString ();
}
}

5 - 16

Algoritmos sobre pilas

A diferencia de lo que ocurra en el caso de las listas donde estudiamos que la ordenacin
era uno de los problemas recurrentes, en el caso de las pilas se considera que tal 6po de
manipulaciones no son de inters ya que iran en contra de la esencia organiza6va del 6po
mantener a los elementos dispuestos en el orden de llegada de acuerdo a una pol6ca LIFO.
Por ello, en esta seccin nos centraremos en discu6r el problema del recorrido de los
elementos de una pila y la bsqueda de un elemento dentro de una pila.
I. Recorrido
II. Bsqueda
La bsqueda de un elemento sobre los elementos de una pila se realiza de
forma secuencial dada la definicin del tipo lo que imprime un coste lineal al
algoritmo. Si esta operacin no fuese una operacin interna del tipo dicha
bsqueda sera destructiva o requerira utilizar un iterador (con copia) o
reconstruir la estructura tras el algoritmo. La bsqueda como operacin
interna permite implementar el algoritmo no destructivamente sobre la
estructura interna.
5 - 17
Independencia de la
implementacin
Algoritmos
sobre pilas
El recorrido de los elementos de una pila devuelve un iterador que permite

acceder secuencialmente a los mismos segn aparecen almacenados en la
estructura, en sentido desde la cima hasta la base de la pila. El recorrido en
sentido contrario es fcilmente implementable y se deja como ejercicio


Para ar6cular el recorrido secuencial de los elementos de una pila debe implementarse el
interfaz IteratorIF. Las implementaciones de StackIF anteriores construyen una copia de la
pila como manejador para garan6zar que la iteracin no modique el estado del 6po
class StackIterator<T> implements IteratorIF<T>
{
private StackIF<T> handler;
Iteracin con reset
private StackIF<T> restart;
Se mantienen 2 manejadores constantemente,

/**
uno para articular el recorrido de la pila. El otro
* Constructor para StackIterator.
siempre apunta a la cima de la pila y se utiliza
* @param handler el manejador de pilas.
para implementar la operacin de reset del
*/
public StackIterator (StackIF<T> handler)
iterador
{
this.handler = handler;
this.restart = new StackDynamic<T> (handler);
}

getNext()
/**
* Devuelve el siguiente elemento de la iteracion.
* @return el siguiente elemento de la iteracion.
*/
handler
restart
@Override
public T getNext ()
Avance
{
T top = handler.getTop ();
La operacin de avance devuelve el elemento en
handler.pop ();
cima de la pila y actualiza el manejador de
return top;
recorrido extrayendo la cima. Para invocar esta
}
4
3
2
1
operacin con seguridad hay que asegurarse de

que el manejador no apunta a la cola vaca
5 - 18


Para ar6cular el recorrido secuencial de los elementos de una pila debe implementarse el
interfaz IteratorIF. Las implementaciones de StackIF anteriores construyen una copia de la
pila como manejador para garan6zar que la iteracin no modique el estado del 6po
/**
* Devuelve cierto si existen mas elementos a iterar.
* @return cierto si existen mas elementos a iterar.
*/
@Override
public boolean hasNext ()
{
return !handler.isEmpty ();
}

/**
* Restablece el iterador para volver al inicio
*/
@Override
public void reset ()
{
handler = new StackDynamic<T> (restart);
}

@Override
public int hashCode () { ... }

@Override
public boolean equals (Object o) { ... }

@Override
public String toString () {...}
}
5 - 19
Hay siguiente
Para saber si el iterador contiene ms elementos y por
tanto puede volver a invocarse la operacin de avance o
no, hay que preguntar si el manejador ha alcanzado el final
de la pila
Reset
Una vez que un iterador ha llegado a su fin slo se puede
construir otro iterador, o resetear este a su valor inicial. En
este caso sin embargo, la operacin de reset requiere una
copia con lo que el coste es idntico al de construir un
nuevo iterador.
handler
reset ()
handler
4
3
2
1
restart

Bsqueda de un elemento sobre una pila

La bsqueda de un dato sobre los elementos contenidos en una pila es un problema de
recorrido secuencial que termina cuando se encuentra una cima que corresponde con el
dato buscado. El problema es que la bsqueda sobre el 6po es destruc6va a no ser que se
aplique sobre la implementacin o se u6lice un iterador
Bsqueda itera8va con cen8nela

En la bsqueda con cen6nela se itera sobre
la pila y se u6liza una guarda (cen6nela) para
indicar el momento en que se ha encontrado
el elemento y la bsqueda puede parar
/**
* Devuelve cierto si la pila contiene el elemento.
* @return cierto si la pila contiene el elemento.
*/
@Override
{
IteratorIF<T> stackIt = this.getIterator ();
boolean found = false;
while (!found && stackIt.hasNext ()) {
T anElement = stackIt.getNext ();
found = anElement.equals (element);
}
return found;
}

5 - 20
Bsqueda recursiva
En la bsqueda recursiva se comprueba si la
cabeza se corresponde con el elemento
buscado. Si es as el algoritmo termina
devolviendo cierto y si no, se recurre sobre
el resto de la pila para buscar el elemento
/**
* Devuelve cierto si la lista contiene el elemento.
* @return cierto si la lista contiene el elemento.
*/
@Override
{
if (isEmpty ()) return false;
return this.element.equals (element) ||
next.contains (element);
}

Ejercicios
Dado el carcter destruc6vo de las operaciones sobre pilas para avanzar en una pila es
necesario extraer su cima con pop la realizacin de muchos de sus algoritmos requiere de
un proceso de proteccin consistente en hacer una copia de la misma. Ignorando el
problema de destruccin resuelva los siguientes problemas
I. Longitud de una pila
Disee una funcin que calcule el
nmero de elementos que con6ene
una pila
IV. Elemento base
Devolver una lista con los elementos

de una pila segn aparecen en sta
desde la cima hasta la base
V. Insertar en la base
Disee una funcin que devuelva el

elemento base de una pila
VII. Pila inversa
Disee una funcin que inserte un

dato como elemento en la base de
una pila
VIII. Borrado de un elemento
Disee una funcin recursiva que

devuelva una pila con los elementos
colocados de forma inversa a otra
X. Pila prefijo
Disee una funcin que devuelva una

pila que elimine la primera aparicin
de un elemento
XI. Pila sufijo

pila con los elementos que preceden
a (estn encima de) un elemento
dado
5 - 21
II. Pasar a lista
Disee una funcin que devuelva la

pila con los elementos que suceden a
(estn debajo de) un elemento dado
III. Subpila
Disee una funcin que dada una
lista determine si sta est contenida
en una pila como subpila
VI. Concatenar dos pilas

devuelva la pila resultante de
concatenar dos pilas
IX. Borrar todos

pila donde se hayan eliminado todas
las apariciones de un elemento
XII. Pila mayores

devuelva una pila con todos los
elementos mayores a uno dado

Problemas
Las pilas son un 6po abstracto de datos que se u6liza recurrentemente en los problemas de
cierta complejidad de programacin. A con6nuacin planteamos algunos ejemplos de
problemas que se resuelven con el uso de pilas.
Las torres de Hanoi
El juego, en su forma ms tradicional, consiste en

tres varillas ver6cales. En una de las varillas se apila
un nmero n de discos. Los discos se apilan sobre
una varilla en tamao decreciente. No hay dos
discos iguales, y todos ellos estn apilados de
mayor a menor radio en una de las varillas,
quedando las otras dos varillas vacantes.
El juego consiste en pasar todos los discos de la varilla ocupada a una de las otras varillas
vacantes. Para realizar este obje6vo, es necesario seguir tres simples reglas:
1.
2.
3.
5 - 22
Slo se puede mover un disco cada vez.

Un disco de mayor tamao no puede descansar sobre uno ms pequeo que l mismo.
Slo puedes desplazar el disco que se encuentre arriba en cada varilla.

Problemas
La carta blanca
La nalidad del Solitario Carta blanca es

mover todas las cartas desde la zona del
tablero a las casillas de palo: los cuatro
recuadros situados en la parte superior
derecha del tablero. Para ganar, el jugador
6ene que hacer cuatro montones de
cartas en las casillas, uno por cada palo, y
amontonarlas en orden ascendente desde
el AS hasta el REY. Puedes mover las cartas
de una columna a otra ordenando las
cartas de mayor a menor y alternando los
colores de los palos, as como u6lizar las casillas libres para apartar cartas de las columnas y
as acceder a la carta que hay debajo. La par6da naliza cuando el jugador ha movido todas
las cartas a las casillas de palo o cuando ya no puede realizar ningn movimiento ms. Se dice
que todas las par6das de Carta blanca pueden ganarse.
5 - 23

Problemas
Calculadora en notacin postfija
Aunque actualmente las calculadores permiten

operar con expresiones en notacin inja,
tradicionalmente ha sido frecuente encontrar
mquinas que requeran introducir las
expresiones en notacin posdija. Esto facilita la
forma de calculo y evita el uso de paren6zacin
para desambiguar. De esta manera, 2 + 3 * 5 se
expresa en notacin posdija como 2 3 + 5 * y
debe interpretarse como que a los operandos
5 - 24

Bibliograia
BibliograTa
Bibliografa bsica
Estructuras de datos en java. Weiss, Mark
Allen. Pearson Addison Wesley. ISBN
9788478290352
5 - 25

Bibliograia
BibliograTa
Bibliografa complementaria
Estructura de datos y algoritmos en java. A.
Drozdek. Thomsom. ISBN: 9706866116. 2007
5 - 26
Estructuras de datos con Java. J. Lewis, J.

Chase. Pearson Addison Wesley. ISBN 13:
9788420541914

T5 - TAD Lineales - Pilas

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

T5 - TAD Lineales - Pilas

Hochgeladen von

Copyright:

Verfügbare Formate

Estrategias

de programacin y estructuras de datos

Departamento de Lenguajes y Sistemas inform6cos

Javier Vlez Reyes Jos Ignacio Mayorga Toledano

Tipos abstractos de datos lineales. Pilas

Tipos abstractos de datos lineales

El tipo abstracto de datos Pila

Interfaz del tipo abstracto de datos Pila

Implementaciones del tipo abstracto de datos Pila

Implementacin con Lista

Algoritmos sobre Pilas

Recorrido de los elementos de una Pila

Bsqueda de un elemento sobre una Pila

Tipos abstractos de datos lineales. Pilas

Conocer la interfaz del tipo abstracto de datos Pila

Aprender a implementar el TAD Pila mediante la interfaz StackIF

En versin esttica (con limitacin explcita de capacidad mxima)

En versin dinmica (sin limitacin explcita de capacidad mxima)

Utilizando una lista

Conocer los principales problemas algortmicos sobre pilas

Recorrido de los elementos de una pila

Bsqueda de un elemento sobre una pila

Practicar el diseo de funciones recursivas sobre pilas

Tipos abstractos de datos lineales. Pilas

Tipos abstractos de datos lineales

El tipo abstracto de datos Lista representa una estructuras de datos

Tipos abstractos de datos lineales. Pilas

El 8po abstracto de datos Pila

Tipos abstractos de datos lineales. Pilas

La interfaz del 8po abstracto de datos Pila StackIF <T>

La operacin pop extrae el elemento en la cima

Este predicado indica si la pila no contiene

public interface StackIF <T>

Tipos abstractos de datos lineales. Pilas

La interfaz del 8po abstracto de datos Pila StackIF <T>

En implementaciones con capacidad mxima

El recorrido de una pila devuelve un iterador

Tipos abstractos de datos lineales. Pilas

Implementacin del 8po abstracto de datos Pila StackIF <T>

Implementacin dinmica basada en elemento y siguiente

Ul8mo, elemento fantasma

Cada objeto Pila contiene un atributo para

La pila es una secuencia

Aunque en otras implementaciones el valor del

Tipos abstractos de datos lineales. Pilas

Implementacin dinmica basada en elemento y siguiente

* Los comentarios de las cabeceras se

Tipos abstractos de datos lineales. Pilas

Implementacin dinmica basada en elemento y siguiente

* Los comentarios de las cabeceras se

Tipos abstractos de datos lineales. Pilas

Implementacin del 8po abstracto de datos Pila StackIF <T>

Implementacin est8ca basada en array

El resto de elementos del

Tipos abstractos de datos lineales. Pilas

Implementacin est8ca basada en array

public StackStatic (ListIF<T> list)

Tipos abstractos de datos lineales. Pilas

Implementacin est8ca basada en array

* Los comentarios de las cabeceras se

Tipos abstractos de datos lineales. Pilas

Implementacin del 8po abstracto de datos Pila StackIF <T>

Implementacin basada en lista

Tipos abstractos de datos lineales. Pilas