Colecciones y la Pila

ADT
Ing. Msc. Eddy Miranda Velasquez
 Colecciones
Colección:

Es un grupo de términos que se tratan como una

única unidad conceptual
La selección adecuada de una coleccion para
un determinado problema puede mejorar la
eficiencia y la simplicidad de la solución.
Vista Conceptual de una Pila
 Vista Conceptual de una Pila
Agregar un elemento(Push)
Vista Conceptual de una Pila
 Pilas
• Pila : es una colección cuyos elementos se agregan y
remueven de uno de los extremos llamado cima(top)
de la Pila
• La Pila es una estructura de dato de tipo LIFO (Last
In, First Out)
Una pila es una estructura LIFO
Orden en que los datos son agregados

3-7
 Operaciones con Pilas
• push: agregar un elemento en la cima de la pila

push ( item 4)

item 4
item 3 item 3
item 2 item 2
item 1 item 1
 Operaciones con Pilas
• pop: remover el elemento que esta en la cima (top) de
la pila (stack)
pop ()

item 4
item 3 item 3
item 2 item 2
item 1 item 1
 Operaciones con Pilas
• peek: examina el elemento que esta en la
cima(top) de la pila sin removerlo

item 4
item 3 peek item 4

item 2
item 1
 Operaciones con Pilas
• size: numero de elementos en la pila
• isEmpty: verdadero si la pila esta vacia
• toString: string representacion de la pila

item 4 size 4
item 3 isEmpty false
toString “Pila:
item 2
item 4
item 1 item 3
Item 2
item 1”
 Abstract Data Type (ADT)
Tipo de Dato Abstracto
Es una colección de datos con las operaciones
sobre los datos.

El ADT especifica que hacen las operaciones , no

Como lo hacen.
• push
• pop
• Peek.
• Size
• isEmpty
• toString
 Pila(Stack) ADT
• Stack Abstract Data Type (Stack ADT)
Es una colección de datos en conjunto
con las operaciones sobre esos datos:
• push
• pop
• peek
• size
• isEmpty
• toString
 Abstracción

• La abstracción separa el propósito de una entidad de su

implementación o de la manera como trabaja
• Ejemplo de la vida real: un auto(nosotros no necesitamos
saber como un motor funciona para manejar un auto)
• Ejemplo en sistemas de computacion: una computadora
(no necesitamos saber como se almacena la informacion y
como lo manipula el CPU para poder ejecutar programas)
Abstracción en Programación
Tipo de dato : un conjunto de valores y
operaciones definidos sobre esos valores
Ex. Tipo de dato entero(int):
• Valores: … -2, -1, 0, 1, 2, …
• Operaciones: +, -, x, /, …

Un tipo de dato es definido por un lenguaje de

programación.
 Pila(Stack) ADT
Es una colección de datos en conjunto
con las operaciones sobre esos datos:
• push
• pop
• peek
• Size
• isEmpty
• toString

Un ADT Atack es definido por un programador

 Interfaces de Java

Java tiene una construccion de programación llamada

interfaz que Podemos usar para definir cuales son la
operaciones de dicho ADT.
 Interfaces de Java (cont)
• Una interfaz de java es una lista de
métodos abstractos (las firmas de los
metodos) y constantes
• Todos deben ser de tipo public
• Las constantes deben ser declaradas
como static final
public interface StackADT<T> {
// Agrega un elemento en el top de la pila
public void push (T dataItem);
//Quita y retorna el elemento que está en el top de la pila
public T pop( );
// Retorna el elemento que esta en el top de la pila
public T peek( );
// Retorna verdadero si la pila esta vacia
public boolean isEmpty( );
// Retorna el numero de elementos de la pila
public int size( );
// Retorna la representacion en cadena de la pila
public String toString( );
}
 Tipos Genéricos
¿Qué es esto<T> en la definicion de interface?
• Este es llamado un tipo genérico.
• El interface anterior define un Stack de objetos
de tipo T
• El tipo actual es conocido solamente cuando un
programa aplicación crea un objeto de esa clase.
• Ejemplo:
• StackADT<String> s = new …
• StackADT<Persona> p = new …
• StackADT<Rectangulo> r = new …
…
 Tipos Genéricos
Nota: Es solamente convencional usar la letra T para
representar un tipo generico; es decir se puede usar
cualquier otra letra para representar un tipo genérico
En una definición de clase , encerramos el tipo generico
con parentesis angulares: <T>
public interface StackADT<TipoGenerico> {

public void push (TipoGenerico dataItem);

public TipoGenerico pop( );
public TipoGenerico peek( );
public boolean isEmpty( ); T es reemplazado
Por TipoGenerico
public int size( );
En el interface
public String toString( ); StackADT; .
}

3-22
 Implementando un Interface
• No se puede crear un objeto de la interfaz(clase)
StackADT.
• Para poder crear objetos de tipo Stack, primero
necesitamos crear una clase que implemente la
interfaz proporcionando implementaciones
(código) a cada uno de los metodos abstractos de
la interfaz
 Problemas al Implementar Stacks

• ¿Qué se necesita implementar un Stack?

• Una estructura de dato(container) para sostener a
los datos
• Algo que indique la cima (top) y el fondo(bottom) de
la pila.
Implementación de un Stack con un Array
bottom
Implementación de un Stack con un Array
Implementación de un Stack
con un Array
Implementación de un Stack
con un Array
Implementación de un Stack con un
Array
Implementación de un Stack con un
Array
Implementación de un Stack con un
Array
Implementación de un Stack con un
Array
public interface StackADT<T> {
// Agrega un elemento en el top de la pila
public void push (T dataItem);
//Quita y retorna el elemento que está en el top de la pila
public T pop( );
// Retorna el elemento que esta en el top de la pila
public T peek( );
// Retorna verdadero si la pila esta vacia
public boolean isEmpty( );
// Retorna el numero de elementos de la pila
public int size( );
// Retorna la representacion en cadena de la pila
public String toString( );
}
public class ArrayStack<T> implements StackADT<T> {

private T[ ] stack; // Arreglo para los datos

private int top; // Cima de la Pila
private final int DEFAULT_CAPACITY=100;
public ArrayStack( ) {
top = 0;
stack = (T[ ]) (new Object[DEFAULT_CAPACITY]);
}
public ArrayStack (int initialCapacity) {
top = 0;
stack = (T[ ]) (new Object[initialCapacity]);
}

3-34
 Ejemplo: uso de un constructor
para crear un Stack de Strings

ArrayStack<String> s =
new ArrayStack<String>(5);

top

0
s
stack

DEFAULT_CAPACITY = 100
0 1 2 3 4
Code references
Ejemplo: el mismo objeto ArrayStack despues de
que cuatro items fueron insertados(push)

ArrayStack<String> s =
new ArrayStack<String>(5);

top
“s1” “s3”
4
s
stack

DEFAULT_CAPACITY = 100
0 1 2 3 4
Code references
“s0” “s2” 3-36
public class ArrayStack<T> implements StackADT<T> {

private T[ ] stack; // Array for the data

private int top; // Top of stack
private final int DEFAULT_CAPACITY=100;
public ArrayStack( ) {
top = 0;
stack = (T[ ]) (new Object[DEFAULT_CAPACITY]);
}
public ArrayStack (int initialCapacity) {
top = 0;
stack = (T[ ]) (new Object[initialCapacity]);
}

Porque esta declaracion compleja?

public class ArrayStack<T> implements StackADT<T> {

private T[ ] stack; // Array for the data

private int top; // Top of stack
private final int DEFAULT_CAPACITY=100;
public ArrayStack( ) {
top = 0;
stack = (T[ ]) (new Object[DEFAULT_CAPACITY]);
}
public ArrayStack (int initialCapacity) {
top = 0;
stack = new Object[initialCapacity];
}

Que hay de raro?

public class ArrayStack<T> implements StackADT<T> {

private T[ ] stack; // Array for the data

private int top; // Top of stack
private final int DEFAULT_CAPACITY=100;
public ArrayStack( ) {
top = 0;
stack = (T[ ]) (new Object[DEFAULT_CAPACITY]);
}
public ArrayStack (int initialCapacity) {
top = 0;
stack = (T[ ]) (new Object[initialCapacity]);
}
Implementación de un Stack con un Array: Push

3-40
//----------------------------------------------------------
// Agrega el element especifico a la cima de la pila,
// expandiendo la capacidad del arreglo si es necesario
//----------------------------------------------------------
public void push (T dataItem) {
if (top == stack.length)
expandCapacity( );

stack[top] = dataItem;
top++;
}

3-41
// Metodo auxiliar para crear un nuevo arreglo para
// almacenar loscontenidos de la pila con el doble de
// su capacidad

private void expandCapacity( ) {

T[ ] larger = (T[ ]) (new Object[stack.length*2]);

for (int index=0; index < stack.length; index++)

larger[index] = stack[index];

stack = larger;
}

3-42
Implementación de un Stack con un
Array Pop
Pop ()

3-43
// Remueve el element que esta en la cima de la pila y devuelve
// una referencia a el
public T pop( ) {
if (top == 0)
System.out.println(“La Pila esta Vacia” );
top--;
T topItem = stack[top];
stack[top] = null;
return topItem;
}

3-44
Implementación de un Stack
con un Array
Peek ()
// Retorna el elemento que se encuentra en la cima de la pila.

public T peek( ) {
if (top == 0)
System.out.println(“Pila vacia” );
return stack[top-1];
}
// Retorna el numero de elementos de la Pilas
public int size( ) {
return top;
}

// Retorna verdadero si la Pila esta vacia

public boolean isEmpty( ) {
return (top == 0);
}

3-47
//------------------------------------------------
// Retorna una representacion String en la Pila.
//------------------------------------------------
public String toString( ) {
String result = “Stack:\n";

for (int index=0; index < top; index++)

result = result + stack[index].toString( )
+ "\n";

return result;
}
}

3-48
El uso de Pilas en Computación

Son muy útiles en cualquier proceso

involucra a datos en LIFO
• Backtracking: en resolver un laberinto o
Encontrando una ruta en un mapa

3-49
 El uso de Pilas en Computación
• Procesadores de texto o editores
• Para evaluar expresiones o strings de
texto para emparejar los parentesis y
llaves.
e.g.

if (a == b) {
c = ((d + e) – f) * (d + e);
}
• To implement undo operations
3-50
• Keeps track of the most recent
 El uso de Pilas en Computación
• Procesadores de texto o editores
Para implementar la operaciones undo

Mantiene el registro de la mas recientes

operaciones
if (a == b)) c =

3-51
Muchas Gracias

3-52