Universidad de Estudios Superiores de La Paz

Carrera: Licenciatura en Informática

Asignatura: Estructura de datos

Tema: Pilas

Profesora: Ing. Roxana

Nombre del alumno: Hernández Mejía Brayan Alfredo

Grupo: LI-131

Fecha de entrega: Viernes 22 de octubre del 2010

Definición:
Las pilas son otro tipo de estructura de datos lineales, las cuales
presentan restricciones en cuanto a la posición en la cual pueden
realizarse las inserciones y las extracciones de elementos.

Una pila es una lista de elementos en la que se pueden insertar y

eliminar elementos sólo por uno de los extremos. Como consecuencia,
los elementos de una pila serán eliminados en orden inverso al que se
insertaron. Es decir, el último elemento que se metió a la pila será el
primero en salir de ella.

En la vida cotidiana existen muchos ejemplos de pilas, una pila de platos

en una alacena, una pila de latas en un supermercado, una pila de
papeles sobre un escritorio, etc.

Debido al orden en que se insertan y eliminan los elementos en una pila,

también se le conoce como estructura LIFO (Last In, First Out: último en
entrar, primero en salir).

Para el manejo de los datos se cuenta con dos operaciones básicas:

apilar (push), que coloca un objeto en la pila, y su operación inversa,
retirar (o desapilar, pop), que retira el último elemento apilado.

En cada momento sólo se tiene acceso a la parte superior de la pila, es

decir, al último objeto apilado (denominado TOS, Top of Stack en inglés).
La operación retirar permite la obtención de este elemento, que es
retirado de la pila permitiendo el acceso al siguiente (apilado con
anterioridad), que pasa a ser el nuevo TOS.

Por analogía con objetos cotidianos, una operación apilar equivaldría a

colocar un plato sobre una pila de platos, y una operación retirar a
retirarlo.

Las pilas suelen emplearse en los siguientes contextos:

• Evaluación de expresiones en notación postfija (notación polaca

inversa).
• Reconocedores sintácticos de lenguajes independientes del
contexto
• Implementación de recursividad.
Operaciones:
Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a
las que en las implementaciones modernas de las pilas se suelen añadir
más de uso habitual.

• Crear: se crea la pila vacía.

• Apilar: se añade un elemento a la pila.(push)
• Desapilar: 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.

Componentes:
Una Pila se compone de los siguientes elementos:

• Arreglo de datos
• El numero máximo
• El numero mínimo
• El tipo de datos de la pila
• los índices Tope y Base de la Pila
• Operaciones Elementales
• Iniciar
• Insertar
• Eliminar
• Axiomas
• Insertar:

Si Tope = Máximo
 Mensaje( O Verflow?)

de lo Contrario

Tope = Tope +1

Pila Tope = Valor

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.

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.

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.

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:

Manzana Plátano

Plátano ==rotar a la derecha==> Fresa

Fresa Manzana

Fresa Manzana

Plátano ==rotar a la izquierda==> Fresa

Manzana Plátano

Una pila es normalmente representada en los ordenadores por un

bloque de celdas de memoria, con los "de abajo" en una ubicación fija, y
el puntero de pila de la dirección actual de la "cima" de células de la
pila. En la parte superior e inferior se utiliza la terminología con
independencia de que la pila crece realmente a la baja de direcciones de
memoria o direcciones de memoria hacia mayores.
Apilando un elemento en la pila, se ajusta el puntero de pila por el
tamaño de elementos (ya sea decrementar o incrementar, en función de
la dirección en que crece la pila en la memoria), que apunta a la próxima
celda, y copia el nuevo elemento de la cima en área de la pila.
Dependiendo de nuevo sobre la aplicación exacta, al final de una
operación de apilar, el puntero de pila puede señalar a la siguiente
ubicación no utilizado en la pila, o tal vez apunte al máximo elemento de
la pila. Si la pila apunta al máximo elemento de la pila, el puntero de pila
se actualizará antes de que un nuevo elemento se apile, si el puntero
que apunta a la próxima ubicación disponible en la pila, que se
actualizará después de que el máximo elemento se apile en la pila.

Desapilando es simplemente la inversa de apilar. El primer elemento de

la pila es eliminado y el puntero de pila se actualiza, en el orden opuesto
de la utilizada en la operación de apilar.

Soporte de Hardware:
Muchas CPUs tienen registros que se pueden utilizar como punteros de
pila. Algunos, como el Intel x86, tienen instrucciones especiales que
implícitamente el uso de un registro dedicado a la tarea de ser un
puntero de pila. Otros, como el DEC PDP-11 y de la familia 68000 de
Motorola tienen que hacer frente a los modos de hacer posible la
utilización de toda una serie de registros como un puntero de pila. La
serie Intel 80x87 numérico de coprocessors tiene un conjunto de
registros que se puede acceder ya sea como una pila o como una serie
de registros numerados. Algunos microcontroladores, por ejemplo
algunos PICs, tienen un fondo fijo de pila que no es directamente
accesible. También hay una serie de microprocesadores que aplicar una
pila directamente en el hardware:

• Computer vaqueros MuP21

• Harris RTX línea
• Novix NC4016

Muchas pilas basadas en los microprocesadores se utilizan para aplicar

el lenguaje de programación Forth en el nivel de microcódigo. Pila
también se utilizaron como base de una serie de mainframes y
miniordenadores. Esas máquinas fueron llamados pila de máquinas, el
más famoso es el Burroughs B5000

Soporte de Software:
En programas de aplicación escrito en un lenguaje de alto nivel, una pila
puede ser implementada de manera eficiente, ya sea usando vectores o
listas enlazadas. En LISP no hay necesidad de aplicar la pila, ya que las
funciones apilar y desapilar están disponibles para cualquier lista. Adobe
PostScript también está diseñada en torno a una pila que se encuentra
directamente visible y manipuladas por el programador. El uso de las
pilas está muy presente en el desarrollo de software por ello la
importancia de las pilas como tipo abstracto de datos.

Expresión de evaluación y análisis sintáctico:

Se calcula empleando la notación polaca inversa utilizando una
estructura de pila para los posibles valores. Las expresiones pueden ser
representadas en prefijo, infijo, postfijo. La conversión de una forma de
la expresión a otra forma necesita de una pila. Muchos compiladores
utilizan una pila para analizar la sintaxis de las expresiones, bloques de
programa, etc. Antes de traducir el código de bajo nivel. La mayoría de
los lenguajes de programación son de contexto libre de los idiomas que
les permite ser analizados con máquinas basadas en la pila.

Por ejemplo, el cálculo: ((1 + 2) * 4) + 3, puede ser anotado como en

notación postfija con la ventaja de no prevalecer las normas y los
paréntesis necesarios:

12+4*3+

La expresión es evaluada de izquierda a derecha utilizando una pila:

• Apilar cuando se enfrentan a un operando y

• Desafilar dos operandos y evaluar el valor cuando se enfrentan a una
operación.
• Apilar el resultado.

De la siguiente manera (la Pila se muestra después de que la operación

se haya llevado a cabo):

ENTRADA OPERACION PILA

1 Apilar operando 1
2 Apilar operando 1, 2
+ Añadir 3
4 Apilar operando 3, 4
* Multiplicar 12
3 Apilar operando 12, 3
+ Añadir 15

El resultado final, 15, se encuentra en la parte superior de la pila al final

del cálculo.
Ejemplos en Java:
1: Con un código explicado

/**
*
* @Alumno Hernández Mejía Brayan Alfredo
* @Grupo LI-131 T.M.
* @Escuela UES La paz
* @Materia Estructura de datos
* @Semestre 3er semestre de Lic. en informática
*
*/
import java.util.Stack;
// que en ingles Stack es Pila

public class Pila2 {

/** Creamos una nueva instancia o clase de Pila */
public static void main(String []args) {

Stack pila = new Stack();

Stack pilaString= new Stack();
for(int i=0;i<=10;i++)
{
pila.push(new Integer(i));
// le voy a meter un String que contenga el valor de i
// pero tambien puede ser entre comillas ejemplo
// pilaString.push("hola");
pilaString.push(Integer.toString(i)); //aquí puede ser algo así
}
// como vemos primero metimos el 0
// ahora lo imprimimos
for(int i=0;i<=10;i++)
{
int j=((Integer)pila.pop()).intValue();
System.out.println(i);
}

// imprimiremos la pila String

for(int i=0;i<=10;i++)
{
String str = (String)pilaString.pop();
System.out.println(str);
}
// como deberá suceder el primero en imprimir será el 9.
//
}
}

Esto es lo que nos muestra en pantalla:

Ejemplo 2 Java:

package datos;

/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

/**

* @author Brayan

*/

public class Pila3

{

int tope=-1;

int vec[];

Pila3(int max)

vec=new int [max];

public boolean llena()

if (tope==vec.length-1)

return true;

else

return false;

public boolean vacia()

if (tope==-1)

return true;

else

return false;

public void push(int dato)

{
 if (llena()== true)

System.out.println("Overflow");

else

if (tope==-1)

tope=0;

vec[tope]=dato;

else

tope++;

vec[tope]=dato;

public int pop()

int aux;

if (vacia()==true)

System.out.println("La pila esta vacia");

return -1;

else

{
 aux=vec[tope];

tope--;

return aux;

public void Imprime_Datos()

if(vacia()==true)

System.out.println("La pila esta vacia, ingrese datos

primero:");

else

for(int Contador=0;Contador<vec.length;Contador++)

System.out.println("Los valores de la pila

son:"+vec[Contador]);