Pila

Una pila (stack) es una coleccin ordenada de elementos a los cuales slo se puede
acceder por un nico lugar o extremo de la pila. Los elementos se aaden o se quitan
(borran) de la pila slo por su parte superior (cima). Este es el caso de una pila de platos,
una pila de libros, etc. Una pila es una estructura de datos de entradas ordenadas que
slo se pueden introducir y eliminar por un extremo, llamado cima.
La operacin Insertar (push) sita un elemento dato en la cima de la pila, y Quitar (pop) elimina o
quita el elemento de la pila.

Especificaciones de una pila

Las operaciones que sirven para definir una pila y poder manipular su contenido son las siguientes
(no todas ellas se implementan al definir una pila):

Operaciones

Dato que se almacena en la pila

Crear Pila
Insertar (push)
Quitar (pop)
Pila vaca
Pila llena
Limpiar pila
Cima Pila
Tamao de la pila

Inicia.
Pone un dato en la pila.
Retira (saca) un dato de la pila.
Comprueba si la pila no tiene elementos.
Comprueba si la pila est llena de elementos.
Quita todos sus elementos y deja la pila vaca.
Obtiene el elemento cima de la pila.
Nmero de elementos mximo que puede
contener la pila.

Ejemplo 1
Escribir un programa que cree una pila de enteros y realice operaciones de aadir datos a la pila,
quitar...
Se supone implementada la pila con el tipo primitivo int. El programa crea una pila de nmeros
enteros, inserta en la pila elementos ledos del teclado (hasta leer la clave -1) y a continuacin
extrae los elementos de la pila hasta que se vaca. El bloque de sentencias se encierra en un
bloque try para tratar errores de desbordamiento de la pila.
package TipoPila;
public class PilaLineal
{
private static final int TAMPILA = 49;
private int cima;
private TipoDeDato []listaPila;
public PilaLineal()
{
cima = -1; // condicin de pila vaca
listaPila = new TipoDeDato[TAMPILA];
}

// operaciones que modifican la pila

public void insertar(TipoDeDato elemento){...}
public TipoDeDato quitar(){...}
public void limpiarPila(){...}
// operacin de acceso a la pila
public TipoDeDato cimaPila(){...}
// verificacin estado de la pila
public boolean pilaVacia(){...}
public boolean pilaLlena(){...}

import TipoPila.PilaLineal;
import java.io.*;
class EjemploPila
{
public static void main(String [] a)
{
PilaLineal pila;
int x;
final int CLAVE = -1;
BufferedReader entrada = new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Teclea los elemento (termina con -1).");
try {
pila = new PilaLineal(); // crea pila vaca
do {
x = Integer.parseInt(entrada.readLine());
pila.insertar(x);
}while (x != CLAVE);
System.out.println("Elementos de la Pila: ");
while (!pila.pilaVacia())
{
x = pila.quitar();
System.out.print(x + " ");
}
}
catch (Exception er)
{
System.err.println("Excepcion: " + er);
}
}
}

Notacin prefija y notacin postfija de una expresin aritmtica

La forma habitual de escribir operaciones aritmticas (notacin infija) sita el operador entre sus
dos operandos. Esta forma de notacin obliga, en muchas ocasiones, a utilizar parntesis para
indicar el orden de evaluacin. Las expresiones siguientes: r = a*b/(a+c) g = a*b/a+c
Existen otras formas de escribir expresiones aritmticas, que se diferencian por la ubicacin del
operador respecto de los operandos. La notacin en la cual el operador se coloca delante de los
dos operandos, se conoce como notacin prefija y se conoce como notacin polaca (en honor del
matemtico polaco que la propuso).
Se escribe, paso a paso, la transformacin de cada expresin aritmtica en la expresin
equivalente en notacin polaca.
a*b/(a+c) (infija) a*b/+ac *ab/+ac /*ab+ac (polaca)
a*b/a+c (infija) *ab/a+c /*aba+c +/*abac (polaca)
(a-b)^c+d (infija) -ab^c+d ^-abc+d +^-abcd (polaca)

Notacin postfija
Hay ms formas de escribir las expresiones. La tercera notacin ms utilizada se denomina postfija
o polaca inversa y coloca el operador a continuacin de sus dos operandos.
Paso a paso, se transforma cada subexpresin en notacin postfija.
a*b/(a+c) (infija) a*b/ac+ ab*/ac+ ab*ac+/ (polaca inversa)
a*b/a+c (infija) ab*/a+c ab*a/+c ab*a/c+ (polaca inversa)
(a-b)^c+d (infija) ab-^c+d ab-c^+d ab-c^d+ (polaca inversa)

Conversin de Infijo a Prefijo por

medio de pilas

PilaDefinitiva.push(PilaTemp
.pop());
PilaTemp.pop();
break;
default:
PilaDefinitiva.push(caracter);
}

import javax.swing.JOptionPane;
public class Pilas {
public static void main(String[] args) {
String text =
JOptionPane.showInputDialog("Dame
infijo :");
System.out.println("Prefijo : "+
Infijo2PrefijoTxt(text));
}
public static String
Infijo2PrefijoTxt(String infijo){
Pila p1 = Infijo2Prefijo(infijo);
String text = "";
while (p1.i > 0)
text += p1.pop();
return text;
}
public static Pila Infijo2Prefijo(String
infijo) {
infijo = '(' + infijo ; // Agregamos al
final del infijo un ')'
int tamao = infijo.length();
Pila PilaDefinitiva = new
Pila(tamao);
Pila PilaTemp = new Pila(tamao);
PilaTemp.push(')'); // Agregamos a
la pila temporal un '('
for (int i = tamao-1; i > -1; i--) {
char caracter = infijo.charAt(i);
switch (caracter) {
case ')':
PilaTemp.push(caracter);
break;
case '+':case '-':case '^':case
'*':case '/':
while (Jerarquia(caracter) >
Jerarquia(PilaTemp.nextPop()))
PilaDefinitiva.push(PilaTemp
.pop());
PilaTemp.push(caracter);
break;
case '(':
while (PilaTemp.nextPop() != ')')

}
return PilaDefinitiva;
}
public static int Jerarquia(char
elemento) {
int res = 0;
switch (elemento) {
case ')':
res = 5; break;
case '^':
res = 4; break;
case '*': case '/':
res = 3; break;
case '+': case '-':
res = 2; break;
case '(':
res = 1; break;
}
return res;
}
}

Evaluar expresin Postfija usando

pilas.
package evalpost;
import java.util.Stack;
public class EvalPost {
public static void main(String[] args) {
//Entrada (Expresin en Postfija)
String expr = "2 23 6 + * 1 -"; // equivale a
2*(23+6)-1
String[] post = expr.split(" ");
//Declaracin de las pilas
Stack < String > E = new Stack < String >
(); //Pila entrada
Stack < String > P = new Stack < String >
(); //Pila de operandos

System.out.println("Expresion: " + expr);

System.out.println("Resultado: " +
P.peek());

//Aadir post (array) a la Pila de entrada

(E)
for (int i = post.length - 1; i >= 0; i--) {
E.push(post[i]);
}

}
private static int evaluar(String op, String n2,
String n1) {
int num1 = Integer.parseInt(n1);
int num2 = Integer.parseInt(n2);
if (op.equals("+")) return (num1 + num2);
if (op.equals("-")) return (num1 - num2);
if (op.equals("*")) return (num1 * num2);
if (op.equals("/")) return (num1 / num2);
if (op.equals("%")) return (num1 % num2);
return 0;
}

//Algoritmo de Evaluacin Postfija

String operadores = "+-*/%";
while (!E.isEmpty()) {
if (operadores.contains("" + E.peek())) {
P.push(evaluar(E.pop(), P.pop(), P.pop())
+ "");
}else {
P.push(E.pop());
}
}

//Mostrar resultados:

Cola
Una cola es una estructura de datos que almacena elementos en una lista y permite acceder a los
datos por uno de los dos extremos de la lista (Figura 10.1). Un elemento se inserta en la cola (parte
final) de la lista y se suprime o elimina por el frente (parte inicial, frente) de la lista. Las aplicaciones
utilizan una cola para almacenar elementos en su orden de aparicin o concurrencia.
Una cola es una estructura de datos cuyos elementos mantienen un cierto orden, de tal modo que slo
se pueden aadir elementos por un extremo, final de la cola, y eliminar o extraer por el otro extremo,
llamado frente.

Especificaciones del tipo abstracto de datos Cola

Las operaciones que sirven para definir una cola y poder manipular su contenido son las
siguientes:

Operaciones

Dato que se almacena en la pila

CrearCola
Insertar
Quitar
Cola vaca
Cola llena
Frente
Tamao de la cola

Inicia la cola como vaca.

Aade un elemento por el final de la cola.
Retira (extrae) el elemento frente de la cola.
Comprueba si la cola no tiene elementos.
Comprueba si la cola est llena de elementos.
Obtiene el elemento frente o primero de la cola.
Nmero de elementos mximo que puede
contener la cola

Ejemplo 2
Encontrar un numero capica ledo del dispositivo estndar de entrada.
El algoritmo para encontrar un nmero capica utiliza conjuntamente una Cola y una Pila. El
nmero se lee del teclado, en forma de cadena con dgitos. La cadena se procesa carcter
acarcter, es decir, dgito a dgito (un dgito es un carcter del 0 al 9). Cada dgito se pone en una
cola y, a la vez, en una pila. Una vez que se terminan de leer los dgitos y de ponerlos en la Colay

en la Pila, comienza el paso de comprobacin: se extraen en paralelo elementos de la cola y de la

pila, y se comparan por igualdad. De producirse alguna no coincidencia entre dgitos, significa que
el nmero no es capica, y entonces se vacan las estructuras para pedir, a continuacin, otra
entrada. El nmero es capica si el proceso de comprobacin termina con la coincidencia de todos
los dgitos en orden inverso y tanto la pila como la cola quedan vacas. Por qu utilizar una pila y
una cola? Sencillamente porque aseguran que se procesan los dgitos en orden inverso; en la pila,
el ltimo en entrar es el primero en salir; en la cola, el primero en entrar es el primero en salir. Se
usa la clase PilaVector implementada con un Vector y la clase ColaCircular implementada con un
array circular.
while (! pilaVacia())
package TipoPila;
quitar();
import java.util.Vector;
}
public class PilaVector
}
{
private static final int INICIAL = 19;
private int cima;
private Vector listaPila;
public PilaVector()
package TipoCola;
{
public class ColaCircular
cima = -1;
{
listaPila = new Vector(INICIAL);
private static fin int MAXTAMQ = 99;
}
protected int frente;
public void insertar(Object elemento)throws
protected int fin;
Exception
protected Object [] listaCola ;
{
// avanza una posicin
cima++;
private int siguiente(int r)
listaPila.addElement(elemento);
{
}
return (r+1) % MAXTAMQ;
public Object quitar() throws Exception
}
{
//inicializa la cola vaca
Object aux;
public ColaCircular()
if (pilaVacia())
{
{
frente = 0;
throw new Exception ("Pila vaca, no se
fin = MAXTAMQ-1;
puede extraer.");
listaCola = new Object [MAXTAMQ];
}
}
aux = listaPila.elementAt(cima);
// operaciones de modificacin de la cola
listaPila.removeElementAt(cima);
public void insertar(Object elemento) throws
cima--;
Exception
return aux;
{
}
if (!colaLlena())
public Object cimaPila() throws Exception
{
{
fin = siguiente(fin);
if (pilaVacia())
listaCola[fin] = elemento;
{
}
throw new Exception ("Pila vaca, no se
else
puede extraer.");
throw new Exception("Overflow en la cola");
}
}
return listaPila.elementAt(cima);
public Object quitar() throws Exception
}
{
public boolean pilaVacia()
if (!colaVacia())
{
{
return cima == -1;
Object tm = listaCola[frente];
}
frente = siguiente(frente);
public void limpiarPila()throws Exception
return tm;
{
}

else
throw new Exception("Cola vacia ");
}
public void borrarCola()
{
frente = 0;
fin = MAXTAMQ-1;
}
// acceso a la cola
public Object frenteCola() throws Exception
{
if (!colaVacia())
{
return listaCola[frente];
}
else
throw new Exception("Cola vacia ");
}
// mtodos de verificacin del estado de la
cola
public boolean colaVacia()
{
return frente == siguiente(fin);
}
// comprueba si est llena
public boolean colaLlena()
{
return frente == siguiente(siguiente(fin));
}
}
import TipoPila.PilaVector;
import TipoCola.ColaCircular;
import java.io.*;
public class Capicua
{
public static void main(String [] a)
{
boolean capicua;
BufferedReader entrada = new
BufferedReader(
new InputStreamReader(System.in));
String numero;
PilaVector pila = new PilaVector();
ColaCircular q = new ColaCircular();
try {
capicua = false;
while (!capicua)
{
do {
System.out.print("\nTeclea el nmero: ");

numero = entrada.readLine();
}while (! valido(numero)); // todos dgitos
// pone en la cola y en la pila cada dgito
for (int i = 0; i < numero.length(); i++)
{
Character c;
c = new Character(numero.charAt(i));
q.insertar(c);
pila.insertar(c);
}
// se retira de la cola y la pila para comparar
do {
Character d;
d = (Character) q.quitar();
capicua = d.equals(pila.quitar());//compara
por igualdad
} while (capicua && !q.colaVacia());
if (capicua)
System.out.println(numero + " es capica. ");
else
{
System.out.print(numero + " no es capica,
");
System.out.println(" intente otro. ");
// se vaca la cola y la pila
q.borrarCola();
pila.limpiarPila();
}
}
}
catch (Exception er)
{
System.err.println("Error (excepcion) en el
proceso: " + er);
}
}
private static boolean valido(String numero)
{
boolean sw = true;
int i = 0;
while (sw && (i < numero.length()))
{
char c;
c = numero.charAt(i++);
sw = (c >= '0' && c <= '9');
}
return sw;
}
}