Está en la página 1de 23

PILAS

Definición.- Una pila es una lista de elementos de estructuras de


datos dinámicos que almacenan información de un solo tipo, a la
cual se añaden, eliminan, ordenan, cambian, etc. solo por un
extremo llamado tope. La pila es una estructura de datos dinámicos
con numerosas aplicaciones o analogías en la vida real.
El acceso a esta lista es de tipo LIFO, donde el último elemento que
se introduce en la pila es el primer elemento en ser extraído.
FILOSOFÍA.- La filosofía que se emplea es “Último en entrar,
primero en salir”, “Last in, First out, LIFO”
OPERACIONES BÁSICAS
APILAR (PUSH): Coloca un elemento en la pila
DESAPILAR (POP): Retira un elemento de la pila
isEmpty (vario), true, en caso de ser VACIO
EJEMPLOS
Una apilación de platos de loza.
Una apilación de monedas,
Una apilación de objetos metálicos.
Una apilación de cajas de zapatos
Mineros que entran en el socabon
Filas de personas con fichas
Entradas a los buses
PILA DE CONEJOS

PILA
TOP LIMITE
PILAS
REPRESENTACIÓN EN UNA COMPUTADORA
Las pilas están definidas en los diferentes lenguajes de
programación de manera escueta, y elemental que se fundamentan
mediante punteros simples, punteros múltiples, las mismas que se
implementan en vectores tipo Object y listas encadenadas. Para
esto se define el tamaño máximo (límite máximo) o el tope de la pila
y el puntero llamado TOP que señala la posición del último
elemento insertado en la pila.
PILA = P(1), P(2), P(3), … , P(n)
CONDICIONES
Si tope = 0 entonces, la pila esta vacía.
Si tope = límite entonces, la pila esta llena.
CREAR PILAS Y VERIFICAR VACIO
/* PROYECTO FINAL */
class Pilassimple #include<stdio.h>
{ final int limite = 10; int top; #include<conio.h>
Object p []=new Object [limite]; #include<stdlib.h>
Pilassimple () #include<ctype.h>
#include<string.h>
{ top = 0; }
#include<iostream.h>
#define ENTER 13
5 tam
4
#define ESC 27
3 #define tam 100
1 #define tam 10
0 tope typedef struct pila
{int tami[100];
void addp (Object e) int tope; } p;
{ p [top] = e; top++; } void creacsi (p *d1)
{d1->tope=0; }
VERIFICAR LLENO, ADICIONAR Y ELIMINAR EN PILA
boolean verificavacio ()
{ if (top == 0) return true; void adicionacsi (p *d1,int e)
else return false; } {if (d1->tope <tam)
boolean verifllena () {d1->tami[d1->tope] =e;
d1->tope=d1->tope +1; }
{ if (top == limite) return true; else {printf ("pila llena");}
else return false; }
} tam void mostrarcsi(p d1)
{ int i;
top for (i=0;i<d1.tope;i++)
55
66 { printf("\npila[%d]=%d",i,d1.tami[i]); }
Object delpila () 77 }
void eliminarcsi(p *d1,int *e)
{ top = top – 1; return (v [top]); } {if(d1->tope>0)
void verpila () {d1->tope=d1->tope-1;
{ System.out.println ("pila:\t"); *e=d1->tami[d1->tope];
}
for (int i = 0 ; i < top ; i++) else
System.out.println ("en la {printf("pila vacia");
pocision [“+i +"]se encuentra el }
}
elemento [“+v [i]+"]");
ORDENAR, BUSCAR EN PILA
void intercambia (int n, int m)
{ void ordenacsi(p *d1)
int i = 0, j = 0, sw = 0, sw1 = 0; {
Object aux;
System.out.print("\nDESPUES DEL INTERCAMBIO\n"); int i,j,aux;
while (i < t && sw == 0) for (i=0;i< d1->tope-1;i++)
{ if (i == n) {for (j=i;j<d1->tope;j++)
{ sw = 1;
while (j < t && sw1 == 0) {if (d1->tami[i] <d1->tami[j])
{ if (j == m) {
{ sw1 = 1; aux = p [i]; aux= d1->tami[i];
p [i] = p [j]; p [j] = aux;
} d1->tami[i]=d1->tami[j];
else d1->tami[j]=aux;
j++; }
}
} }
else }
i++; }
}
MENÚ PRINCIPAL EN JAVA Y C++

int delensupos (int dato)


{ void pilasimples()
int sw = 0; {p d1;
//Object aux; int ps;
int i = 0; int e;
while (i < t) do{
{ if (Integer.parseInt (p [i].toString ()) clrscr();
== dato) cout<<"\n\n\n\t\t**MENU PILAS
{ sw = 1; SIMPLES*";
while (i < t - 1) printf("\n1.- crea \n");
{ p [i] = p [i + 1]; i++; } printf("2.- adicionar \n");
elimp (); i = 0; printf("3.- mostrar \n");
} printf("4.- eliminar\n");
else printf("5.- ordena\n");
{ i++; } printf("6.- salir al menu principal\n");
}System.out.print ("\nDESPUES DE LA scanf ("%d",&ps);
ELIMINACION\n"); switch(ps)
listap ();
return sw;
}
MENÚ PRINCIPAL EN JAVA Y C++
void buscap (int n) switch(ps)
{ for (int i = 0 ; i < t ; i++) {case 1:clrscr(); creacsi(&d1);
{ if (n == Integer.parseInt (p [i].toString ())) printf("\npila creada"); getch();
System.out.println (n + " SE ENCUENTRA EN break;
LA POSICION " + i); case 3:clrscr(); printf("\nlos elementos de la
} pila son");
} mostrarcsi(d1);
void ordenap () getch(); break;
{ case 2:clrscr();
int i, j; printf("\nelemento a adiconar");
Object aux; scanf("%d",&e);
for (i = 0 ; i < t ; i++) adicionacsi(&d1,e);
{ for (j = i + 1 ; j < t ; j++) break;
{ if (Integer.parseInt (p [i].toString ()) > case 4 :clrscr(); eliminarcsi(&d1,&e);
Integer.parseInt (p [j].toString ())) printf("\nelemento a eliminar");
{ aux = p [i]; p [i] = p [j]; p [j] = printf("%d",e); getch(); break;
aux; case 5 :clrscr(); ordenacsi(&d1);
} printf("de manera ordenad es...... ");
} mostrarcsi(d1); getch(); break;
} }
} }while(ps< 6 );
}
{ m = m * (Integer.parseInt (p [i].toString switch (op)
())); } { case 1: sw = 1; do { if (!x.verifllena
MENÚ PRINCIPAL
System.out.print ("\nLA MULTI DE LOS ELEM EN
()) JAVA Y C++
DE LA PILA ES= “+m); {System.out.print ("\t\tAdicionar el
} elemento--->");
public static void main (String args []) e = Leer.dato (); x.addp (e); }
//public static void pilas ()
else {System.out.println ("\t*pila
{ Pilassimple x = new Pilassimple ();
Object e; int op, a, b, sw,t=1; llena* ");}
do System.out.print ("DESEA SEGUIR ADI
{ System.out.println ("\n\n"); (si=1/no=0)->");
System.out.print ("\t\t\t__PILAS sw = Leer.datoInt ();
SIMPLES________ \n"); } while (sw != 0); break;
System.out.println case 2:if (!x.verifvacia ()) {x.listap
("\t\t=====================\n"); (); }
System.out.println ("\t\t\t1. ADICIONA
ELEMENTO ");
else System.out.println ("\t**pila
System.out.println ("\t\t\t2. LISTA PILA "); vacia** ");
System.out.println ("\t\t\t3. ELIMINA break;
ULTIMO ELEMENTO "); case 3: if (!x.verifvacia ()) { e = x.elimp
System.out.println ("\t\t\t4. ORDENA ESTA ();
PILA"); System.out.print ("el elem elimi fue-
System.out.println ("\t\t\t5. BUSCA > " + e); }
ELEMENTOS");
else System.out.println ("\t**pila
System.out.println ("\t\t\t6. INTERCAMBIA
ELEMENTOS");
vacia** ");
System.out.println ("\t\t\t7. ELIM EL break;
ELEMENTO DESEADO"); case 4: if (!x.verifvacia ()) { x.ordenap ();
System.out.print ("QUIERE INTERCAMBIAR LA POSICION--->");
MENÚ ();
a = Leer.datoInt PRINCIPAL EN JAVA Y C++
System.out.print ("CON LA POSICION--->\t\t"); b = Leer.datoInt ();
x.intercambia (a, b); break;
} else System.out.println ("\t**pila vacia** "); break;
case 7: if (!x.verifvacia ()) { System.out.print ("QUE
ELEMENTO DESEA ELIMINAR--->");
a = Leer.datoInt (); b = x.delensupos (a);
if (b == 0) { System.out.print ("EL ELEMENTO NO EXISTE
EN LA PILA"); }
else System.out.print ("ELEMENTO ELIMINADO
FUE--->" + a); break;
} else System.out.println ("\t**pila vacia** ");
break;
case 8: if (!x.verifvacia ()) { x.listap (); x.multiplica (t);
break; }
else System.out.println ("\t**pila vacia** ");
break;
case 0: op = 0; System.out.println("<==== ELIJA UNA OPCION DEL MENU
PRINCIPAL\n\n\n"); break;
default: System.out.print ("\tERROR!!!!!!");
}
//menu pilas
class pilas PILA EN JAVA, OTRA
{ public static final int lim = 50;
VERSIÓN
class sol_2
{ public static void adicion (pilas A, int me)
public int tope; public int[] p; { int n; try
pilas () { for (int i = 1 ; i <= me ; i++)
{ tope = 0; p = new int [lim]; } { System.out.println ("La pila->");
public void poner (int e) throws Exception n = Leer.datoInt (); A.poner (n);
{ if (tope < lim) } }
{ tope++; p [tope] = e; } catch (Exception er)
else { throw new Exception ("Desborde { System.err.println ("EXCEPCION : " +
de Pila");} } er); } }
public int quitar () throws Exception public static int poner (pilas A)
{ int aux; { pilas aux = new pilas (); int e, e1;
if (tope > 0) { aux = p [tope]; tope--; try
} { e = A.quitar (); aux.poner (e);
else while (A.tope != 0) { e1 = A.quitar
{throw new Exception ("pila vacia no ();
puede extraer"); } if (e1 < e) { e = e1; }
return aux; } aux.poner (e1);
public void listar () } while (aux.tope != 0)
{ if (tope == 0) { System.out.println {e1 = aux.quitar (); A.poner (e1); }
("pila vacia"); } return (e);
else { for (int i = tope ; i >= 1 ; i--) }
{ System.out.println ("[" + p [i] + catch (Exception er)
"]"); } { System.err.println ("EXCEPCION : " +
else { sw = System.out.println ("\n");
} MENÚ int n, w, q, K = 0; pilas A = new pilas ();
1; } PRINCIPAL
while (aux.tope != 0)
EN JAVA Y C++
while (K <= 5)
{ e = aux.quitar (); A.poner (e); { System.out.println ("\t(1)
} } ADICIONAR.");
catch (Exception er) System.out.println ("\t(2)
{ System.err.println ("EXCEPCION : MOSTRAR.");
" + er); } } System.out.println ("\t(3) ELIMINAR.
public static void ordenar (pilas A) ");
{ pilas ao = new pilas (); int e; System.out.println ("\t(4)
try ORDENAR.");
{ while (A.tope != 0) System.out.println ("\t(5) BUSCAR."); K =
{ e = poner (A); eliminar (A, e); Leer.datoInt ();
ao.poner (e); } switch (K) {
System.out.println ("PILA case 1: System.out.println ("INT
ORDENADA"); ao.listar (); } DIMENCION DE LA PILA : ");
catch (Exception er) n = Leer.datoInt (); adicion (A, n);
{ System.err.println ("EXCEPCION : " break;
+ er); } } case 2: System.out.println ("PILA ES: ");
public static void buscar (pilas A, int me) A.listar (); break;
{ pilas aux = new pilas (); int sw = 0, e; case 3: System.out.println ("INT
try ELEMENTO A ELIMINAR");
{ while (A.tope != 0) { e= w = Leer.datoInt (); eliminar (A, w);
A.quitar (); break;
if (e == me) {System.out.println (“elem case 4: System.out.println ("LA PILA
PILAS MÚLTIPLES
Definición.- Las pilas múltiples son listas de elementos a la cual se añaden,
eliminan, ordenan, cambiar, etc. solo por un extremo llamado top, en cada una
de las pilas.
El acceso a esta lista es de tipo LIFO, donde el último elemento que se
introduce en la pila es el primer elemento en ser extraído.
FILOSOFÍA.- La filosofía que se emplea es “Último en entrar primero en salir”,
“Last in, First out, LIFO”
La pila es una estructura de datos dinámicos con numerosas aplicaciones o
analogías en la vida real.
REPRESENTACIÓN tam

top top top top


Total = 16 PILA 1 PILA 2 PILA 3 PILA 4
CONCEPTOS GENERALES
CONDICIONES
El total del espacio se divide por el número de pilas en partes iguales
Si top = 0 entonces, la pila esta vacía.
Si top > límite entonces, la pila esta llena.
OPERACIONES
Crear
Adicionar
Eliminar
Listar
Ordenar
Buscar
Intercalar
PROGRAMACIÓN DE PILAS
CREACIÓN PILAS //PILAS MULTIPLES
public class Pilas_multiples #define tamm 10
{ int tcp, tam = 50; struct mpila
Object mpi [] = new Object [50]; { int mp[tam];
int top [] = new int [50]; int top[tam];
int lim [] = new int [50]; int limite[tam];
void crea_mp (int ni) } pilas;
{ int i; tcp = tam / ni; typedef struct mpila mpilas;
for (i = 0 ; i < ni ; i++) mpilas mp,mp1,mp2;
{ top [i] = i * tcp; int tcp;
lim [i] = ((i + 1) * tcp) – 1; } void creamm (mpilas *mp1,int
System.out.print("\tFue np)
creado[“+ni+ "]pilas"); {tcp=tam/np;
} for(int i=0;i<np;i++)
tam {mp1->top[i]=i*tcp;
mp1->limite[i]=((i+1)*tcp)-1;
top top top top } }
void adicionamm(mpilas *mp1,int
ADICIÓN, Y ELIMINACIÓN DEe,int ELEMENTOS
np) EN PILAS
{ if (mp1->top[np-1]<mp1-
>limite[np-1])
void adi_mp (Object e, int ni)
{ mpi [top [ni - 1]] = e;
{ mp1->mp[mp1->top[np-1]] =e;
top [ni - 1]++; mp1->top[np-1]=mp1->top[np-
} 1]+1;
}
else
{ printf ("\npila llena"); }
}
void eliminarmm(mpilas *mp1,int
void elim_mp (int ni) *e,int np)
{ Object e;
top [ni - 1]--; e = mpi [top [ni -
{if(mp1->top[np-1]!=mp1-
1]]; >limite[np-1])
System.out.println ("\tEl elemento {mp1->top[np-1]=mp1->top[np-
[“+e+"]eliminado");
}
1]-1;
*e=mp1->mp[mp1->top[np-1]];
}
for (i = (ni - 1) * tcp ; i < top
LISTAR ELEMENTOS DE LA PILA
[ni - 1] ; i++)
{System.out.println ("[" + mpi
[i] + "]"); void mostrarmm(mpilas mp1,int
} } np)
public static void main(String { int i;
args[]) if(mp1.top[np-1]!=mp1.limite[np-
{ int op, sw = 0, ni, np; 1])
Object e; { for (i=(np-
Pilas_multiples z = new 1)*tcp;i<mp1.top[np-1];i++)
Pilas_multiples (); { printf("\npila[%d]=
while (sw == 0) %d",i,mp1.mp[i]);
{System.out.println ("\n\tMENU }
PILAS "); }
System.out.println ("1.-CREAR else {cout<<"\npila
PILA MULT"); vacia..";getch();}
System.out.println ("2.- }
ADICIONA ELEMEN");
System.out.println ("3.-LISTAR
CONSTRUCCIÓN
System.out.println ("5.-RETORNAR DEL AL void
MENÚ pilasmultiples()
PRINCIPAL
MENU PRINCIPAL "); {int ps,np; int e;
System.out.println ("\n\tELIJA UNA do{
OPCION-->"); clrscr();
op = Leer.datoInt (); cout<<"\n\n\t\t**MENU PILAS
switch (op) MULTIPLES**";
{ printf("\n1.- crea \n");
case 1: if (! verificapila()) printf("2.- adicionar \n");
{ System.out.println ("Cuantas Pilas printf("3.- mostrar \n");
desea Crear"); printf("4.- eliminar\n");
ni = Leer.datoInt (); z.crea_mp printf("5.- salir al menu principal\n");
(ni); } scanf ("%d",&ps);
else System.out.println (“Existe switch(ps)
Pilas“+n); { case 1:clrscr();cout<<"\nInt. el numero de
break; pilas...";
case 2: if (!verificalleno(n)) scanf("%d",&np);
{System.out.println ("Numero de creamm(&mp1,np);
Pila"); printf("\npilas creadas");
np = Leer.datoInt (); getch(); break;
System.out.println ("El Elmento de case 2:clrscr();
la Pila"); printf("\nelemento a adicionar");
e = Leer.dato (); z.adi_mp (e, np); scanf("%d",&e);cout<<"en que pila desea
} adicionar...";
else System.out.println (“La Pila
CONSTRUCCIÓN DEL MENÚ PRINCIPAL
case 3:
System.out.println ("Numero de case 3:clrscr();cout<<"\nque pila desea
Pila"); listar...";
np = Leer.datoInt (); scanf("%d",&np);
z.lista_mp (np); printf("\nlos elementos de la pila son");
break; mostrarmm(mp1,np);
case 4: getch();
System.out.println ("Numero de break;
Pila"); case 4 :clrscr();
np = Leer.datoInt (); cout<<"\nintroduzca la pila a eliminar... \n";
z.elim_mp (np); scanf("%d",&np);
break; eliminarmm(&mp1,&e,np);
case 5: printf("\nelemento a eliminar");
sw = 1; printf("%d",e);
break; getch();
default: break;
System.out.println ("ERROR default:getch();break;
DE OPCION"); }
}while(ps< 5 );
} }
}
}
void buscaelemento (int x)
{ for CONSTRUCCIÓN
(int i = fr ; i != fi ; i DEL
= (i +MENÚ
ObjectEN JAVA Y(Object
delensupos TC++dato)
1) % tam) { int sw = 0; Object aux; int i = fr;
{ if (x==Integer.parseInt (cc while (i < fi)
[i].toString())) {if (Integer.parseInt
{System.out.println ("SE (cc[i].toString())==dato){ sw = 1;
while (i>fr) {cc [i]=cc[i-1]; i=(i-
ENCONTRO EN LA 1)%tam; }
POSICION\t"+i); } } } delcc (); i = fr; }
void ordenacc () else { i = (i + 1) % tam; }
{ Object aux; } listacc (); return sw; }
for (int i = fr ; i != fi ; i = (i + 1) void intercambiar (int n, int m)
{ int i=fr, sw =0, sw1 = 0; Object aux;
% tam) System.out.print ("\n
{for (int j = i + 1 ; j != fi ; j = (j INTERCAMBIO\n");
+ 1) % tam) while (i != fi && sw == 0){ if (i==n)
{ if (Integer.parseInt (cc { sw= 1; int j = fr;
[i].toString ()) > Integer.parseInt while (j != fi && sw1 == 0)
{if (j == m) {sw1=1;aux=cc[i];cc [i]=cc
(cc [j].toString ())) { [j]; cc [j] = aux; }
aux=cc [i]; cc [i] = cc [j]; cc else j = (j + 1) % tam; }
[j]=aux; } } else i = (i + 1) % tam;
//public static void main(String args[])
CONSTRUCCIÓN DEL MENÚ ENstatic
public JAVAvoid Y TC++
colas_circulares ()
{ int op, a, b; Object e;
Colascirculares cc1 = new Colascirculares
boolean vervacio () ();
do
{ if (fr == fi) { System.out.println ("\n\t *COLAS
return true; CIRCULARES*");
System.out.println ("\t\t1.-
else ADICIONAR");
System.out.println ("\t\t2.-
return false; ELIMINAR");
} System.out.println ("\t\t3.-LISTAR");
System.out.println ("\t\t4.-BUSCA
boolean verlleno () ELEMENTO");
{ if ((fi + 1) % tam == fr) System.out.println ("\t\t5.-ORDENA");
System.out.println ("\t\t6.-ELIMINA
ELEMENTO DESEADO");
return true; System.out.println ("\t\t7.-INTERCAMBIA
ELEMENTOS");
else System.out.println ("\t\t8.-SUMA LOS
return false; ELEMENTOS");
System.out.println ("\t\t0.-RETORNAR AL
} PRINCIPAL");
System.out.print ("\t\tELIJA UNA
else System.out.print ("\nCola
CONSTRUCCIÓN DEL MENÚ
llena"); break; case 7:ENifJAVA
(!cc1.vervacio
Y TC++ ())
case 2: if (!cc1.vervacio()) { e = { cc1.listacc ();
cc1.delcc (); System.out.print ("QUIERE
System.out.println ("El dato eliminado INTERCAMBIAR LA POSICION-->\t");
fue" + e); } a = Leer.datoInt ();
else System.out.print ("\nCola System.out.print ("CON LA
vacia"); break; POSICION-->\t\t\t"); b = Leer.datoInt ();
case 3: if (!cc1.vervacio()) cc1.intercambiar (a, b); }
{ System.out.println ("Los datos de la else System.out.print ("\nCola vacia");
cola son:"); cc1.listacc (); } break;
else System.out.print ("\nCola case 8: if (!cc1.vervacio ()) { cc1.suma
vacia"); break; (); }
case 4: System.out.print else System.out.print ("\nCola vacia");
("\tELEMENTO BUSCA->"); break;
b = Leer.datoInt (); case 0: op=0;
cc1.buscaelemento (b); break; System.out.println("<=ELIJA UNA
case 5: if (!cc1.vervacio ()) OPCION DEL MENU PRINCIPAL");
{ cc1.ordenacc (); cc1.listacc (); } break;
else System.out.print ("\nCola default: System.out.println
vacia"); break; ("\t\terror!!"); }
case 6: if (!cc1.vervacio ()) }
while (op != 0);

También podría gustarte