LECCION 3.

1 PILAS

Definición:

Son aquellas que solo tiene 2 operaciones, Push(Inserción) y Pop(Eliminación) la cual solo se puede
efectuar por un extremo llamado Top. Sin Embargo se le pueden aplicar todas las operaciónes al igual
que a las listas.

Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus
elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que
permite almacenar y recuperar datos. Se aplica en multitud de ocasiones en informática debido a su
simplicidad y ordenación implícita en la propia estructura.

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.

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 1

Para entender el funcionamiento de una pila, vamos a ver como trabaja usando un programa escrito en
lenguaje C++. Puedes descargar el programa desde la leccion o teclear el codigo que estara en el
apendice

Recorrido
Definición:

Ya que las pilas son LIFO(Last in - First Out) el Recorrido se hace sacando el ultimo dato que se inserto
hasta que no encuentre ningún otro.

Detalle:

Apuntador toma el Top, después ve si la condición cumple para efectuar un Ciclo mientras Apuntador
sea diferente de Nulo, si cumple lo que hace es que despliega el contenido de la Pila(Pila[Apuntador]),
después Apuntador se le resta 1. Este proceso se repite hasta que Apuntador sea igual Nulo(Cuando
llega a este punto la Pila ya fue Recorrida).

Algoritmo:

Recorrido(Pila, Top)

Apuntador ←- Top

Repetir mientras Apuntador ≠ Nulo

Imprimir Pila[Apuntador]

Apuntador ←- Apuntador - 1

Fin del ciclo

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 2

Salir

Diagrama:

Corrida:

Push

Definición:

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 3

Push es simplemente el método por el cual va agregando un Dato nuevo a la Pila tomando en cuenta la
Capacidad Máxima (Max) de almacenar un dato.

Detalle:

Compara en un principio el Top con Max, si la condición no cumple es imposible insertar mas datos a la
Pila, de otra forma lo que hace es Incrementar el valor de Top, y copia el valor de Elemento en
Pila[Top]. De esta forma el dato ya esta insertado.

Algoritmo:

Push(Pila, Top, Max, Elemento)

Si Top ≠ Max

Top ←- Top + 1

Pila[Top] ←- Elemento

Si no:

Imprimir “Pila Llena”

Salir

Diagrama:

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 4

Corrida:

Pop

Definición:

Pop es simplemente el método por el cual va sacando el ultimo Dato de la Pila, basándose únicamente
en el Top.

Detalle:

Compara para determinar si la pila esta vacio, de otra forma lo que hace es Imprimir el valor de
Pila[Top] (Que es el dato que esta apunto de Eliminar) y enseguida a Top le resta 1, de esta forma el
dato ya no existe.

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 5

Algoritmo:

Pop(Pila, Top)

Si Top ≠ Nulo

Imprimir Pila[Top]

Top ←- Top - 1

Si no:

Imprimir “Pila Vacía”

Salir

Diagrama:

Corrida:

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 6

 Búsqueda

Definición:

Este método usa el recorrido para encontrar Elemento y desplegar un mensaje si la búsqueda es exitosa.

Detalle:

El algoritmo compara para determinar si la Pila tiene algún dato, si no simplemente desplegara Lista
Vacía y saldrá. De otra manera hará un Recorrido y comparara con cada uno de los Datos de la Pila
hasta encontrar el dato que desea buscar. Si lo encuentra desplegara “El Dato fue encontrado” de otra
manera “El Dato no se encontró”.

Algoritmo:

Busqueda(Pila, Top, Elemento)

Si Top ≠ Nulo

Apuntador ←- Top

Repetir mientras Apuntador ≠ Nulo

Si Pila[Apuntador] = Elemento

Imprimir “El Dato fue encontrado” y Salir

Apuntador ←- Apuntador - 1

Fin del ciclo

Imprimir “El Dato no se encontró”

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 7

Si no:

Imprimir “Pila Vacía”

Salir

Diagrama:

Corrida:

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 8

 Eliminacion
Definición:

Este método busca un Dato dentro de la pila y lo elimina.

Detalle:

El algoritmo compara para determinar si la Pila tiene algún dato, si no simplemente desplegara Pila
Vacía y saldrá. De otra manera hará un Recorrido y comparara con cada uno de los Datos de la Pila
hasta encontrar el dato que desea eliminar, mientras hace esto copia cada uno de los datos a un arreglo
Temp para cuando encuentre el Dato regresar esos valores a la Pila. Si lo encuentra desplegara
“Eliminado el Dato” y le restara 1 a Top, de otra manera “El Dato no encontrado”.

Algoritmo:

Borrar(Pila, Temp, Top, Elemento)

Si Top ≠ Nulo

Apuntador1 ←- Top

Repetir mientras Apuntador1 ≠ Nulo

Si Pila[Apuntador1] = Elemento

Imprimir “Eliminando el Dato…”

Repetir mientras Apuntador2 ≠ Nulo

Pila[Apuntador1]=Temp[Apuntador2]

Fin del ciclo

Top ←- Top - 1 y Salir

Si No:

Temp[Apuntador2] ←- Pila[Apuntador1]

Apuntador1 ←- Apuntador1 - 1

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 9

Apuntador2 ←- Apuntador2 + 1

Fin del ciclo

Imprimir “Dato no encontrado”

Si no:

Imprimir “Pila Vacía”

Salir

Diagrama:

Corrida:

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 10

 A continuacion, se muestra el algoritmo en pseudocodigo de cómo quedaria el programa para las PILAS.
Este algoritmo esta creado usando el software SLE 2.0, que es mas poderoso que el PseInt y es muy semejante a
C++. En el Apendice, viene el codigo completo en C++, pero para necesitamos darnos una idea general del
algoritmo.
NOTA: Este algoritmo tiene un modulo que no esta escrito. Como ejercicio, deberas crearlo (puedes
basarte en el programa en C++ del Apendice)

/* Algoritmo que muestra el funcionamiento de las PILAS */

/* El programa no esta completo, ya que falta algo, el alumno debera
identificar que es... */
programa Pilas
var
pila : vector [10] numerico
top = 0
max = 10
res,op : numerico

inicio
mientras (op<>6)
{
cls()
imprimir ("\n1) Recorrido\n2) Busqueda\n3) Push\n4) Pop\n5) Eliminar Dato\n6) Salir")
imprimir ("\nQue deseas hacer? ")
leer (op)
si (op == 1 )
{
imprimir ("\nSelecciono recorrido")
recorrido()
readkey()
sino si (op == 2 )
imprimir ("\nQue numero deseas buscar?")
leer (res)
busqueda( res )
readkey()

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 11

 sino si ( op == 3 )
imprimir ("\nQue numero deseas insertar?")
leer (res)
push_insertar( res )
sino si (op == 4 )
imprimir ("\nSelecciono Pop")
pop_sacar()
recorrido()
readkey()
sino si (op == 5 )
imprimir ("\nSelecciono Eliminar")
sino
imprimir ("\nsalida")
}
}
fin

subrutina push_insertar ( valor : numerico )

/* Insertar un elemento */
var
ok=" "
inicio
si (top <> max )
{
top= top + 1
pila[top] = valor
sino
imprimir ("\nPila Llena")
readkey()
}
fin

subrutina recorrido()
/* Mostrar todos los elementos de la pila */
var
k : numerico
inicio
si (top <> -1 )
{
desde k=1 hasta 10
{
imprimir ("\nPila: ",pila[k] )
}
sino
imprimir ("\nPila Vacia")
readkey()
}
fin

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 12

 subrutina busqueda( valor:numerico)
var
i:numerico
inicio
desde i=1 hasta 10
{
si (valor == pila[i] )
{
imprimir ("\nDato ",pila[i]," encontrado en la posicion ",i,"\nPulsa una tecla para salir")
readkey()
salir
sino
imprimir ("\nDato NO encontrado...")
readkey()
}
}
fin

subrutina pop_sacar()
inicio
si (top<>-1)
{
imprimir ("\nSacando el dato: ",pila[top])
pila[top]=0
top = top - 1
readkey()
sino
imprimir ("\nPila vacia... Imposible eliminar")
}
fin

Para ver el funcionamiento de este algoritmo puedes descargar el programa PILAS.EXE que se encuentra
en la seccion biblioteca del curso.

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 13

 APENDICE
Codigo en lenguaje C++ de una pila.

**#include <stdio.h>**
#include <conio.h>
#include <string.h>
#include <iomanip.h>
#include <iostream.h>

class Alumno
{
private:
int Pila[10],Top,Max;
char Pila1[10][10];
public:
Alumno()

{
int i,j;
char Nulo[2]=" ";
Max=9;
Top=-1;
for(i=1;i<9;i++)
{
Pila[i]=0;
strcpy(Pila1[i],Nulo);
}
}

void Push(char Elem[10])

{
if(Top!=Max)
{
Top++;
strcpy(Pila1[Top],Elem);
}
else
cout<<"Pila Llena"<<endl;
}

void Push(int Elem)

{
if(Top!=Max)
{
Top++;
Pila[Top]=Elem;
}
else
cout<<"Pila Llena"<<endl;
}

void Push(float Elem)

{

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 14

if(Top!=Max)
{
Top++;
Pila[Top]=Elem;
}
else
cout<<"Pila Llena"<<endl;
}

void Push(double Elem)

{
if(Top!=Max)
{
Top++;
Pila[Top]=Elem;
}
else
cout<<"Pila Llena"<<endl;
}

void Pop(void)
{
if(Top!=-1)
{
cout<<"Sacando el Dato: "<<Pila[Top];
Top--;
}
else
cout<<"Pila Vacia... Imposible Eliminar"<<endl;
}

void Recorrido(void)
{
if(Top!=-1)
for(int i=Top;i!=-1;i--)
cout<<Pila[i]<<endl;
else
cout<<"Pila Vacia...";
}

void Busqueda(char Elem[10])

{
for(int i=Top;i!=-1;i--)
if((strcmp(Elem,Pila1[i]))==0)
{
cout<<"Dato "<<Pila1[i]<<" encontrado..."<<endl;
return;
}
cout<<"Dato no encontrado..."<<endl;
}

void Busqueda(int Elem)

{
for(int i=Top;i!=-1;i--)
if(Elem==Pila[i])
{

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 15

 cout<<"Dato "<<Pila[i]<<" encontrado..."<<endl;
return;
}
cout<<"Dato no encontrado..."<<endl;
}

void Busqueda(float Elem)

{
for(int i=Top;i!=-1;i--)
if(Elem==Pila[i])
{
cout<<"Dato "<<Pila[i]<<" encontrado..."<<endl;
return;
}
cout<<"Dato no encontrado..."<<endl;
}

void Busqueda(double Elem)

{
for(int i=Top;i!=-1;i--)
if(Elem==Pila[i])
{
cout<<"Dato "<<Pila[i]<<" encontrado..."<<endl;
return;
}
cout<<"Dato no encontrado..."<<endl;
}

void Borrar(char Elem[10])

{
char Temp[10][10];
int i=0,j=Top;
if(Top==-1)
{
cout<<"Pila Vacia... Imposible Eliminar...";
return;
}
while(j!=-1)
{
if((strcmp(Elem,Pila1[j]))==0)
{
cout<<"Dato Eliminado...";
for(i--;i!=-1;j++,i--)
strcpy(Pila1[j],Temp[i]);
Top--;
return;
}
else
{
strcpy(Temp[i],Pila1[j]);
i++;
j--;
}
}
cout<<"Dato no encontrado... Imposible Eliminar...";
return;

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 16

}

void Borrar(int Elem)

{
int Temp[10],i=0,j=Top;
if(Top==-1)
{
cout<<"Pila Vacia... Imposible Eliminar...";
return;
}
while(j!=-1)
{
if(Elem==Pila[j])
{
cout<<"Dato Eliminado...";
for(i--;i!=-1;j++,i--)
Pila[j]=Temp[i];
Top--;
return;
}
else
{
Temp[i]=Pila[j];
i++;
j--;
}
}
cout<<"Dato no encontrado... Imposible Eliminar...";
return;
}

void Borrar(float Elem)

{
int Temp[10],i=0,j=Top;
if(Top==-1)
{
cout<<"Pila Vacia... Imposible Eliminar...";
return;
}
while(j!=-1)
{
if(Elem==Pila[j])
{
cout<<"Dato Eliminado...";
for(i--;i!=-1;j++,i--)
Pila[j]=Temp[i];
Top--;
return;
}
else
{
Temp[i]=Pila[j];
i++;
j--;
}
}

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 17

cout<<"Dato no encontrado... Imposible Eliminar...";
return;
}

void Borrar(double Elem)

{
int Temp[10],i=0,j=Top;
if(Top==-1)
{
cout<<"Pila Vacia... Imposible Eliminar...";
return;
}
while(j!=-1)
{
if(Elem==Pila[j])
{
cout<<"Dato Eliminado...";
for(i--;i!=-1;j++,i--)
Pila[j]=Temp[i];
Top--;
return;
}
else
{
Temp[i]=Pila[j];
i++;
j--;
}
}
cout<<"Dato no encontrado... Imposible Eliminar...";
return;
}
}tec;

main()
{
int res,op=0;
while(op!=6)
{
clrscr();
cout<<"\n1) Recorrido\n2) Busqueda\n3) Push\n4) Pop\n5) Eliminar un Dato\n6)
Salir"<<endl;
gotoxy(1,1);
cout<<"Que deseas hacer?: ";
cin>>op;
gotoxy(1,10);
switch (op)
{
case 1:
tec.Recorrido();
break;
case 2:
cout<<"Que Numero deseas buscar?"<<endl;
cin>>res;
tec.Busqueda(res);
break;

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 18

case 3:
cout<<"Que Numero quieres Insertar?"<<endl;
cin>>res;
tec.Push(res);
break;
case 4:
tec.Pop();
break;
case 5:
cout<<"Que Numero deseas eliminar?"<<endl;
cin>>res;
tec.Borrar(res);
break;
case 6:
cout<<"Salida...";
break;
default:
cout<<"Opcion Erronea"<<endl;
break;
}
getch();
}
}

Y en Visual Basic seria:

Module Module1

Public Sub main()

'crearemos una pila
Dim oPila As Stack
oPila = New Stack
'para añadir valores, usamos el metodo push()
oPila.Push("H") 'este sera el ultimo en salir
oPila.Push("A")
oPila.Push("N")
oPila.Push("D")
oPila.Push("S") 'ESTE SERA EL PRIMERO EN SALIR
'para extraer un valor de la pila, usamos el metodo Pop(),
'dicho valor se eliminara de la lista
While oPila.Count > 0
Console.WriteLine("El Valor obtenido de la lista es: {0}", oPila.Pop)
End While
Console.ReadLine()
End Sub

End Module

---------------------------------------------------------------------------------------------------------------------------

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 19

Module Module1

Public Sub main()

'crearemos una cola
Dim oCola As Queue
oCola = New Queue
'para añadir valores, usamos el metodo enqueue()
oCola.Enqueue("H") 'ESTE SERA EL PRIMERO EN SALIR
oCola.Enqueue("A")
oCola.Enqueue("N")
oCola.Enqueue("D")
oCola.Enqueue("S") 'este sera el ultimo en salir
'para extraer un valor de la cola, usamos el metodo dequeue,
'dicho valor se eliminara de la lista
While oCola.Count > 0
Console.WriteLine("El Valor obtenido de la lista es: {0}", oCola.Dequeue)
End While
Console.ReadLine()
End Sub

End Module

Y en Java quedaria mas o menos asi:

import java.io.Serializable;

public class Pila<Tipo> extends Lista implements Serializable

{

public Pila ()
{
super();
}

public void apilar(Tipo dato)

{
super.addInit(dato);
}

public Tipo desapilar()

{
return (Tipo) super.removeInit();
}

public Tipo cima()

{
return (Tipo) getDato(0);
}
}

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 20

ESTRUCTURAS DE DATOS – LECCION 3.1 PILAS Página 21