Untitled

PILAS
CONCEPTO:
Es una lista ordinal o Estructura de Datos en la
que el modo de acceso a sus elementos es de tipo
LIFO (del ingles Last In First Out, ultimo en
entrar, primero en salir)
 Permite almacenar y recuperar datos

Lizbeth Nicolás Aniceto && Esteban García Ricardo

Se aplica en multitud de ocasiones en Informática debido
a su simplicidad y ordenación implícita en la propia
estructura.

El método de pila para la evaluación de expresiones fue
propuesto en 1955 y dos años después patentado por
Fiedrich L.Bauer, quién recibió en 1988 el premio "IEEE
Computer Society Pioneer Award" por su trabajo en el
desarrollo de dicha estructura de datos.
Lizbeth Nicolás Aniceto && Esteban García Ricardo

Una metáfora que se utiliza con frecuencia es la idea de
una pila de platos en una cafetería con muelle de pila. En
esa serie, sólo la primera placa es visible y accesible para el
usuario, todas las demás placas permanecen ocultas. Como
se añaden las nuevas placas, cada nueva placa se convierte
en la parte superior de la pila, escondidos debajo de cada
plato, empujando a la pila de placas. A medida que la placa
superior se elimina de la pila, la segunda placa se convierte
en la parte superior de la pila. Dos principios importantes
son ilustrados por esta metáfora: En primer lugar la última
salida es un principio, la segunda es que el contenido de la
pila está oculto. Sólo la placa de la parte superior es visible,
por lo que para ver lo que hay en la tercera placa, el primer
y segundo platos tendrán que ser retirados.
Lizbeth Nicolás Aniceto && Esteban García Ricardo
OPERACIONES:

Una pila cuenta con 2 operaciones imprescindibles: apilar y des
apilar, a las que en las implementaciones modernas de las pilas se
suelen añadir más de uso habitual.
Lizbeth Nicolás Aniceto && Esteban García Ricardo
Lizbeth Nicolás Aniceto && Esteban Garcia
Ricardo


Si tenemos un par de
elementos en la pila, uno
de ellos debe estar en la
parte superior de la pila,
que se considera “el más
alto'' en la pila que el otro.
En la figura el elemento F
es el más alto de todos los
elementos que están en la
pila. El elemento D es el
más alto de los elementos
A,B,C, pero es menor que
los elementos E y F.
Pila con 6 elementos.
Lizbeth Nicolás Aniceto && Esteban García
Ricardo


Para describir cómo
funciona esta estructura,
debemos agregar un nuevo
elemento, el elemento G.
Después de haber agregado
el elemento G a la pila, la
nueva configuración es la
que se muestra en la figura.
Operación de insertar el
elemento G en la pila P.
Lizbeth Nicolás Aniceto && Esteban García Ricardo

Cuando se desea retirar un
elemento de la pila, solo basta
ordenar que sea retirado un
elemento; no podemos decir “retira
C de la pila'', porque C no está en la
cima de la pila y solamente
podemos retirar el elemento que
está en la cima. Para que la
sentencia ``retira C de la pila'' tenga
sentido, debemos replantear las
órdenes a algo como:
Retira de la pila hasta que el
elemento retirado sea C. Ni siquiera
es necesario decir: ``Retira un
elemento de la pila...'' porque es
sobreentendido que solamente se
puede sacar un elemento a la vez.

La dinámica de la pila, es
decir, la manera en cómo
entran los datos a la
estructura de datos y
cómo salen, se denomina
fifo, que viene del ingés
first in first out (primero
en entrar, primero en
salir).
Lizbeth Nicolás Aniceto && Esteban García Ricardo
Crear: se crea la pila vacía.
 Apilar: se añade un elemento a la pila.(push)
 Des apilar: se elimina el elemento frontal de la
pila.(pop)
 Cima: devuelve el elemento que esta en la cima de
la pila. (top o peek)
 Vacía: devuelve cierto si la pila está vacía o falso
en caso contrario.

Lizbeth Nicolás Aniceto && Esteban García Ricardo
IMPLEMENTACIÓN:



Un requisito típico de almacenamiento de una pila de n
elementos es O(n). El requisito típico de tiempo de O(1) las
operaciones también son fáciles de satisfacer con un array
o con listas enlazadas simples.
La biblioteca de plantillas de C++ estándar proporciona
una "pila). " clase templated que se limita a sólo
apilar/desapilar operaciones. Java contiene una biblioteca
de la clase Pila que es una especialización de Vector. Esto
podría ser considerado como un defecto, porque el diseño
heredado get () de Vector método LIFO ignora la limitación
de la Pila.
Estos son ejemplos sencillos de una pila con las
operaciones descritas anteriormente (pero no hay
comprobación de errores
Lizbeth Nicolás Aniceto && Esteban García Ricardo
Lizbeth Nicolás Aniceto && Esteban García
Ricardo
EN PYTHON:
class Stack(object): def
__init__(self):
self.stack_pointer = None def
push(self, element):
self.stack_pointer =
Node(element,
self.stack_pointer) def
pop(self): e =
self.stack_pointer.element
self.stack_pointer =
self.stack_pointer.next return
e def peek(self): return
self.stack_pointer.element def
__len__(self): i = 0 sp =
self.stack_pointer while sp: i
+= 1 sp = sp.next return i class
Node(object): def __init__(self,
element=None, next=None):
self.element = element
self.next = next if __name__ ==
'__main__': # small use
example s = Stack() [s.push(i)
for i in xrange(10)] print
[s.pop() for i in xrange(len(s))]
EN MAUDE:

La Pila NV es la pila no vacía, que diferenciamos de la pila normal
a la hora de tomar en cuenta errores. El elemento X representa el
tipo de valor que puede contener la pila: entero, carácter, registro
fmod PILA-GENERICA {X :: TRIV} is sorts Pila{X} PilaNV{X}.
subsorts PilaNV{X} < Pila{X}. ***generadores: op crear: ->
Pila {X} [ctor]. op apilar : X$Elt Pila{X} -> PilaNV{X} [ctor].
***constructores op desapilar : Pila{X} -> Pila{X}.
***selectores op cima : PilaNV{X} -> X$Elt. ***variables
var P : Pila{X}. var E : X$Elt. ***ecuaciones eq desapilar
(crear) = crear. eq desapilar(apilar(E, P)) = P. eq
cima(apilar(E, P)) = E. endfm
Lizbeth Nicolás Aniceto && Esteban García Ricardo
PILA CON PUNTEROS EN C++:
#include<stdio.h>
#include<conio.h>
#define TAM 6
#define MAX TAM-1 typedef struct
{
int tope; int item[TAM];
}pila;
int full(pila *);
int empty(pila *);
void push(pila *, int);
void pop(pila *,int *);
void main() {
pila p,t;
int dato,opc,elemento,flag=0;
p.tope=0;
do { clrscr();
printf("\nMENU-PILA"); printf("\n1-> Insertar elemento");
printf("\n2-> Eliminar elemento");
printf("\n3-> Eliminar elemento X");
printf("\n4-> Visualizar");
printf("\n5-> Salir");
printf("\n\nDe su opci¢n : ");
scanf("%d",&opc); switch(opc)
{
Lizbeth Nicolás Aniceto && Esteban García Ricardo
case 1: if(!full(&p)) // si pila no esta llena
{
printf("\nDe el elemento a insertar: ");
scanf("%d",&dato);
push(&p,dato);
printf("\nElemento insertado...");
}
else
{
printf("\nERROR: Pila llena");
}
break;
case 2: if(!empty(&p))
{
pop(&p,&dato);
printf("\nEl elemento eliminado es %d",dato);
}
else
{
printf("\nERROR: Pila vac¡a");
}
break;
case 3: if(!empty(&p))
{
printf("eliminar elemento seleccionado: ");
scanf("%d",&elemento);
if(p.tope != 1)
{
t.tope=0;
do { pop(&p,&dato);
if (dato != elemento)
{
push(&t,dato);
}
}while(!empty(&p));
do { pop(&t,&dato);
push(&p,dato);
}
while(!empty(&t));
}
else if(dato == elemento)
{
pop(&p,&dato);
} else {printf("el elemento no se encuentra en la pila");
}
}
else
{ printf("\nERROR: Pila vac¡a");
}
break;
Lizbeth Nicolás Aniceto && Esteban García Ricardo
case 4: if(!empty(&p))
{
t.tope=0;
do { pop(&p,&dato);
printf("\n%d",dato);
push(&t,dato);
}
while(!empty(&p));
do { pop(&t,&dato);
push(&p,dato);
}
while(!empty(&t));
}
else
{
printf("\nERROR: Pila vac¡a");
}
break;
case 5:
flag=1; break;
case 6: flag=0;
Break;
default: printf("\nOpci¢n no v lida...");
}
if(!flag)
{
printf("\n\nPresione una tecla para continuar...");
getch();
}
}while(!flag); }
int full(pila *p)
{
return(p->tope==MAX);
}
int empty(pila *p)
{
return(p->tope==0);
}
void push(pila *p,int dato)
{
if(!full(p))
{
(p->tope)++;
p->item[p->tope]=dato;
//elemento[1]=dato
}
else printf("\nOVERFLOW");
void pop(pila *p,int *dato)
{
if(!empty(p))
{
*dato=p->item[p->tope];
(p->tope)--;
}
else printf("\nUNDERFLOW");}
Lizbeth Nicolás Aniceto && Esteban García Ricardo
Lizbeth Nicolás Aniceto && Esteban
García Ricardo
ESTRUCTURAS DE DATOS RELACIONADAS:

El tipo base de la estructura FIFO (el primero en
entrar es el primero en salir)es la cola, y la
combinación de las operaciones de la pila y la cola es
proporcionado por el deque. Por ejemplo, el cambio
de una pila en una cola en un algoritmo de búsqueda
puede cambiar el algoritmo de búsqueda en primera
profundidad (en inglés, DFS) por una búsqueda en
amplitud (en inglés, BFS). Una pila acotada es una
pila limitada a un tamaño máximo impuesto en su
especificación.
PILAS HARDWARE:

Un uso muy común de las pilas a nivel de
arquitectura hardware es la asignación de
memoria.
Lizbeth Nicolás Aniceto && Esteban García Ricardo
ARQUITECTURA BÁSICA DE UNA PILA:

Una pila típica es un área de la memoria de los computadores con un
origen fijo y un tamaño variable. Al principio, el tamaño de la pila es
cero. Un puntero de pila, por lo general en forma de un registro de
hardware, apunta a la más reciente localización en la pila; cuando la pila
tiene un tamaño de cero, el puntero de pila de puntos en el origen de la
pila.
Las dos operaciones aplicables a todas las pilas son:


Una operación apilar, en el que un elemento de datos se coloca en el
lugar apuntado por el puntero de pila, y la dirección en el puntero de pila
se ajusta por el tamaño de los datos de partida.
Una operación desapilar: un elemento de datos en la ubicación actual
apuntado por el puntero de pila es eliminado, y el puntero de pila se
ajusta por el tamaño de los datos de partida.
Lizbeth Nicolás Aniceto && Esteban García Ricardo

Hay muchas variaciones en el principio básico de las operaciones de pila. Cada pila tiene
un lugar fijo en la memoria en la que comienza. Como los datos se añadirán a la pila, el
puntero de pila es desplazado para indicar el estado actual de la pila, que se expande lejos
del origen (ya sea hacia arriba o hacia abajo, dependiendo de la aplicación concreta).

Por ejemplo, una pila puede comenzar en una posición de la memoria de mil, y ampliar
por debajo de las direcciones, en cuyo caso, los nuevos datos se almacenan en lugares que
van por debajo de 1000, y el puntero de pila se decrementa cada vez que un nuevo
elemento se agrega. Cuando un tema es eliminado de la pila, el puntero de pila se
incrementa.

Los punteros de pila pueden apuntar al origen de una pila o de un número limitado de
direcciones, ya sea por encima o por debajo del origen (dependiendo de la dirección en
que crece la pila), sin embargo el puntero de pila no puede cruzar el origen de la pila. En
otras palabras, si el origen de la pila está en la dirección 1000 y la pila crece hacia abajo
(hacia las direcciones 999, 998, y así sucesivamente), el puntero de pila nunca debe ser
incrementado más allá de 1000 (para 1001, 1002, etc.) Si un desapilar operación en la pila
hace que el puntero de pila se deje atrás el origen de la pila, una pila se produce
desbordamiento. Si una operación de apilar hace que el puntero de pila incremente o
decremente más allá del máximo de la pila, en una pila se produce desbordamiento.
Lizbeth Nicolás Aniceto && Esteban García Ricardo

La pila es visualizada ya sea creciente de abajo hacia
arriba (como pilas del mundo real), o, con el máximo
elemento de la pila en una posición fija, o creciente,
de izquierda a derecha, por lo que el máximo
elemento se convierte en el máximo a "la derecha".
Esta visualización puede ser independiente de la
estructura real de la pila en la memoria. Esto significa
que rotar a la derecha es mover el primer elemento a
la tercera posición, la segunda a la primera y la tercera
a la segunda. Aquí hay dos equivalentes
visualizaciones de este proceso:
Lizbeth Nicolás Aniceto && Esteban García Ricardo
Manzana
 Plátano
 Fresa
Al rotar a la derecha:
 Plátano
 Fresa
 Manzana

Lizbeth Nicolás Aniceto && Esteban García Ricardo
Lizbeth Nicolás Aniceto && Esteban García Ricardo
Lizbeth Nicolás Aniceto && Esteban García Ricardo
Lizbeth Nicolás Aniceto && Esteban García Ricardo
Lizbeth Nicolás Aniceto && Esteban García Ricardo