PILAS

DEFINICIÓN DE UNA PILA

Es una estructura de datos (TDA) caracterizada por:
• Es lineal
• Es homogénea: Todos los elementos son del mismo tipo de
dato
• Se tiene acceso solo al extremo denominado CIMA:
• Se puede ver el elemento de la CIMA
• Se puede eliminar el elemento de la CIMA
• Se puede insertar un nuevo elemento por la CIMA
 DEFINICIÓN DE UNA PILA
Debido a que las operaciones de extracción e inserción se
realizan por el mismo extremo, el último elemento en ser
añadido será el primero en ser extraído; por ello a estas
estructuras se las conoce con el nombre de LIFO (last-in,
first-out; último en entrar, primero en salir).
 PILA

GESTIÓN DE
MEMORIA
DINÁMICA

Base de la pila

cima
 EJEMPLOS DE PILAS
Un ejemplo es un montón de platos colocados uno encima del otro: Cuando
se quiere introducir un nuevo plato, éste se coloca en la posición más
accesible, encima del último plato. Cuando se toma un plato, éste se extrae,
igualmente, del punto más accesible, el último que se ha introducido.
Otro ejemplo es una caja llena de libros. Sólo podemos ver cuál es el libro
que está más arriba en la caja, y si ponemos o tomamos un libro, sólo
podremos actuar sobre este primer libro. No podemos siquiera saber el
número total de libros guardados en la pila. Sólo sabremos el número de
elementos de la pila de libros si previamente los sacamos hasta vaciar la
caja.
 EJEMPLOS DE PILAS
Otra aplicación de la estructura pila es durante la ejecución de un
programa de computadora, en la forma en que la máquina procesa las
llamadas a los procedimientos. Cada llamada a un procedimiento (o
función) hace que el sistema almacene toda la información asociada
con ese procedimiento (parámetros, variables, constantes, dirección de
retorno, etc...) de forma independiente a otros procedimientos y
permitiendo que unos procedimientos puedan invocar a otros distintos
(o a si mismos) y que toda esa información almacenada pueda ser
recuperada convenientemente cuando corresponda. Como en un
procesador sólo se puede estar ejecutando un procedimiento, esto
quiere decir que sólo es necesario que sean accesibles los datos de un
procedimiento (el último activado, el que está en la cima). De ahí que la
estructura pila sea apropiada para este fin.
 OPERACIONES CON UNA PILA
INICIACIÓN DE LA ESTRUCTURA:
- CREAR LA PILA: INICIA LA PILA COMO VACÍA

OPERACIONES DE ACCESO, ELIMINACIÓN E INSERCIÓN

1) VER EL ELEMENTO DE LA CIMA
2) ELIMINAR EL ELEMENTO DE LA CIMA
3) INSERTAR UN ELEMENTO POR LA CIMA
4) VERIFICAR SI LA PILA ESTÁ VACÍA
5) VERIFICAR SI LA PILA ESTÁ LLENA (SI PUEDE LLENARSE)
 IMPLEMENTACIÓN DE UNA PILA
UNA PILA PUEDE REPRESENTARSE MEDIANTE:
1. ESTRUCTURAS ESTÁTICAS (CON UN VECTOR)
2. ESTRUCTURAS DINÁMICAS (CON UNA LISTA ENLAZADA)
IMPLEMENTACION DE UNA PILA CON
UN VECTOR
LA CLASE PILA TIENE DOS CAMPOS:
1 VECTOR ELEM, DONDE ESTAN LOS ELEMENTOS DE LA PILA
ELEM
20 5 10
1 2 3 4 ..... MAX
2 CIMA (ENTERO) QUE CONTIENE LA POSICIÓN DEL
ELEMENTO DE LA CIMA
CIMA

3
 CLASE PILA
class Pila {
// campos Pila
int cima; cima
int[] elem; elem[]
MAX
final int MAX=50;
Constructor por defecto
// constructor pilaVacia()
public Pila () pilaLlena()
{ cima=0; ver()
eliminar()
elem = new int[MAX + 1]; insertar(x)
}
// verifica si la pila está vacía
public boolean pilaVacia()
{ return cima==0; }
 CLASE PILA
// verifica si la pila está llena
public boolean pilaLlena() Pila
{ return cima==MAX; } cima
// ver el elemento de la CIMA elem[]
public int ver () MAX
{ return elem[cima]; } Constructor por defecto
// eliminar el elemento de la CIMA pilaVacia()
pilaLlena()
public void eliminar() ver()
{ if (!pilaVacia() ) {cima = cima - 1; } } eliminar()
// insertar un elemento por la CIMA insertar(x)
public void insertar (int x)
{ if (!pilaLlena() ) { cima = cima + 1;
elem[cima] = x; }
}
}
 CLASE OPERACIONES
class Operaciones {
// INSERTAR N ELEMENTOS
public Pila insertarN(Pila p) Operaciones
{ System.out.print("Nº de elementos= ");
int n=Leer.datoInt();
insertarN(p)
int d; mostrar(p)
for(int c=1;c<=n && !p.pilaLlena();++c) eliminarPos(p)
{System.out.print("Dato"+c+"= ");
d=Leer.datoInt();
p.insertar(d);
}
return p;
}
 CLASE OPERACIONES
// MOSTRAR
public void mostrar(Pila p)
{ Pila paux=new Pila(); // SE CREA UNA PILA AUXILIAR VACIA: paux
int d; // SE VACÍA LA PILA p EN LA PILA paux
while(!p.pilaVacia()) {
// SE RECUPERA EL ELEMENTO DE LA CIMA DE LA PILA p Y SE LO MUESTRA
d=p.ver();
System.out.println(" "+d);
p.eliminar(); // SE ELIMINA EL ELEMENTO DE LA CIMA DE p
paux.insertar(d); // SE INSERTA EN LA CIMA DE paux EL ELEMENTO
ELIMINADO DE p
} // AL FINAL LA PILA p QUEDA VACIA Y paux CON LOS ELEMENTOS DE p,
INVERTIDOS
 CLASE OPERACIONES

// SE VACIAN LOS ELEMENTOS DE paux EN p, QUEDANDO COMO ESTABAN

ORIGINALMENTE
while(!paux.pilaVacia()){
d=paux.ver(); // SE RECUPERA EL ELEMENTO DE LA CIMA DE LA PILA paux
paux.eliminar(); // SE ELIMINA EL ELEMENTO DE LA CIMA DE paux
p.insertar(d); // SE INSERTA EN LA CIMA DE p EL ELEMENTO ELIMNADO DE
paux
}
}
 CLASE OPERACIONES
// ELIMINAR LOS ELEMENTOS POSITIVOS
public void eliminarPos(Pila p)
{ Pila paux=new Pila();
int d;
while(!p.pilaVacia())
{d=p.ver();
p.eliminar();
if(d<=0)paux.insertar(d);
}
while(!paux.pilaVacia())
{d=paux.ver();
paux.eliminar();
p.insertar(d);
}
} }
 CLASE PRINCIPAL

Pila pil=new Pila();

Operaciones op = new Operaciones();
pil = op.insertarN(pil);
op.mostrar(pil);
op.eliminarPos(pil);
op.mostrar(pil);
 PROBLEMAS

1. DEFINIR UNA PILA CON ELEMENTOS TIPO doublé

- INSERTAR N ELEMENTOS
- MOSTRAR
- ENCONTRAR EL PROMEDIO DE LOS POSITIVOS
- ENCONTRAR EL MAYOR DE LOS NEGATIVOS
- INSERTAR UN ELEMENTO EN LA BASE D LA PILA