Calculadora A Pilas Ed Final

lOMoARcPSD|16672918
Calculadora a pilas ed final
Estructura de datos (Universidad César Vallejo)
StuDocu is not sponsored or endorsed by any college or university

Downloaded by JOSE YARANGA DE LA CRUZ (joseestig8@gmail.com)
lOMoARcPSD|4159588
lOMoARcPSD|16672918
Calculadora A Pilas ED Final
Algoritmo y estructura de datos (Universidad Nacional Mayor de San Marcos)
StuDocu no está patrocinado ni avalado por ningún colegio o universidad.

Descargado
Downloaded por David
by JOSE SantanaDE
YARANGA Palacios
LA CRUZ(takalssa@hotmail.com)
(joseestig8@gmail.com)
lOMoARcPSD|4159588
lOMoARcPSD|16672918
“Año del Buen Servicio al Ciudadano”
UNIVERSIDAD NACIONAL
MAYOR DE SAN MARCOS
(Universidad del Perú, DECANA DE AMÉRICA)
FACULTAD DE INGENIERÍA DE
SISTEMAS E INFORMÁTICA
Proyecto de Estructura de Datos:

Calculadora Aritmética Usando Pilas
PROFESOR
LUZMILA
INTEGRANTES
LOPEZ TORRES DIEGO
LLALLIHUAMAN CALDERÓN MIGUEL
JARA COAVOY ALEXANDRA
CUSQUISIBÁN RETUERTO XAVIER
FIGUEREDO GIRAO GIANCARLO
3 de diciembre del 2017
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
INDICE
INTRODUCCIÓN ...............................................................................................................2
JUSTIFICACIÓN ...............................................................................................................3
REFERENCIA BIBLIOGRÁFICA .....................................................................................5
DESARROLLO DEL CÓDIGO .........................................................................................8
RESULTADOS ................................................................................................................ 23
CONCLUSIONES............................................................................................................ 24
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
INTRODUCCIÓN
En ciencias de la computación, una estructura de datos es una forma particular de

organizar datos en una computadora para que pueda ser utilizado de manera eficiente.
Diferentes tipos de estructuras de datos son adecuados para diferentes tipos

de aplicaciones, y algunos son altamente especializados para tareas específicas.
Las estructuras de datos son un medio para manejar grandes cantidades de datos de
manera eficiente para usos tales como grandes bases de datos y servicios de indización
de Internet. Por lo general, las estructuras de datos eficientes son clave para
diseñar algoritmos eficientes. Algunos métodos formales de diseño y lenguajes de
programación destacan las estructuras de datos, en lugar de los algoritmos, como el
factor clave de organización en el diseño de software.
Presentamos el siguiente proyecto final asignado al curso con la intención de presentar

los conocimientos aprendidos durante el presente, para poder crear una pequeña
aplicación usando el concepto de Pilas.
Dicho programa implementado en el IDE NetBeans nos muestra el uso de las pilas
haciendo uso de una interfaz gráfica para su mejor uso.
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
JUSTIFICACIÓN
La calculadora a ser implementada debe ser de expresiones aritméticas que evalué
suma, resta, multiplicación y división de la forma:
4 + 5 − (8 + 65 − 23) + 90
Al ser un dato compuesto se llegó a la conclusión de que los datos deben ser tratados
como datos tipo String. De esta forma los datos pueden ser tratados de la misma
manera. Para realizar las siguientes comparaciones.
• Es necesario componer los números como unidades, decenas, centenas

• Es necesario comparar si son llaves o signos aritméticos de evaluación
• Es necesario comparar si son operaciones secundarias (dentro de los
paréntesis) o primarias
Es necesario completar números en caso de punto inicial, signo negativo inicial o luego
de la apertura de un paréntesis.
• Es necesario verificar que no exista espacios vacíos entre los números y/o
operaciones.
Para realizar las operaciones lo primero que se hizo fue relacionar los números para su
tratamiento como datos tipo float.
La segunda etapa se da en la resolución de las operaciones dentro de los paréntesis
La tercera etapa fue insertar en una pila los resultados de las operaciones realizadas
dentro de los paréntesis
Finalmente se realiza las operaciones ya sin paréntesis en la lista.
Ingreso de datos:
34 + (5 + 9) − 99
Se convierte en cadena el dato, verificando la presencia de datos vacíos, 0 y puntos
iniciales:
3 4 + (5 + 9 ) - 9 9
Luego se concatena los datos y se los agrega a la lista:
34 + (5 + 9 ) - 99
Se almacena en una pila las operaciones dentro del paréntesis:
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
En una variable se almacena el resultado de la operación dentro la pila:
14
Se agrega este resultado a la lista:
34 + 14 - 99
Si no existe más paréntesis se hace la operación final:
34 + 14 - 99
Resultado: 147
Las operaciones admitidas son suma resta multiplicación y división.
Para la Interfaz gráfica se capturo el dato jtextField introducido por la ventana de la

interfaz posteriormente este dato es convertido en cadena. La cadena, luego de ser
oprimido el botón “=” es enviada a la lista y esta realiza la operación previamente
validada mediante el método valida existente en la clase lista.
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
REFERENCIA BIBLIOGRÁFICA
DEFINICION DE PILAS:
Una pila es una estructura de datos de acceso restrictivo a sus elementos. Se puede
entender como una pila de libros que se amontonan de abajo hacia arriba. En principio
no hay libros; después ponemos uno, y otro encima de éste, y así sucesivamente.
Posteriormente los solemos retirar empezando desde la cima de la pila de libros, es
decir, desde el último que pusimos, y terminaríamos por retirar el primero que pusimos,
posiblemente ya cubierto de polvo.
Es una estructura de tipo LIFO (Last In First Out), es decir, último en entrar, primero en
salir.
OTRA DEFINICION:
Una pila es una lista en que tanto las inserciones como las
supresiones se hacen por el mismo extremo, que se conoce
como el tope de la pila.
DEFINICION DE COLAS:
Una cola es una estructura de datos de acceso restrictivo a sus elementos. Un ejemplo
sencillo es la cola del cine o del autobús, el primero que llegue será el primero en entrar,
y afortunadamente en un sistema informático no se cuela nadie salvo que el
programador lo diga.
Es una estructura de tipo FIFO (First In First Out), es decir: primero en entrar, primero
en salir.
FUNCIONES Y USOS DE LAS PILAS Y COLAS
FUNCIONES Y USOS DE LAS PILAS:
A. Se emplea en compiladores y editores de texto dirigidos por la sintaxis.

a. Permiten comprobar fácil y eficientemente que los símbolos cuyo uso
solo tiene sentido por parejas (llaves, paréntesis, etc.) estén
adecuadamente balanceados.
B. También se emplea para la evaluación de expresiones.
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
a. Las expresiones escritas en notación convencional (infija, 7 * 2 + 8)

pueden convertirse en notación postfija (7 2 * 8 +) mediante una pila.
b. Las expresiones escritas en notación postfija pueden calcularse
mediante una pila.
c. Una función muy importante de las pilas es la implementación en el
código compilado de las llamadas a función realizadas en el código
fuente.
d. También se emplean para transformar un algoritmo recursivo en otro
iterativo equivalente.
FUNCIONES Y USOS DE LAS COLAS:
A. Se emplea en las operaciones sobre las estructuras de datos de otros TADs por
ejemplo:
a. Recorrido “por niveles” del nodo de un árbol.
b. Recorrido “primero en anchura” de los nodos de un grafo.
c. Obtención “de un orden topológico” de los nodos de un grafo acíclico.
B. Algunos servicios de un sistema operativo también se basan en el TAD cola, por
ejemplo:
a. Servicio de Impresión: Los documentos enviados a una impresora se
sitúan en una “cola de impresión” hasta que pueden ser impresos. Las
peticiones de impresión se gestionan casi como una cola (orden de
llegada, salvo cancelaciones).
b. Planificador: Diferentes estrategias de planificación de procesos (round
robín, prioridades, etc.) emplean colas para los procesos que se van a
ejecutar y determinar en qué orden.
c. También se emplean en algoritmos de simulación para problemas de
teorías de colas.
IMPORTANCIAS DE LAS PILAS Y DE LAS COLAS:
IMPORTANCIA DE LAS PILAS:
En los programas estas estructuras suelen ser fundamentales. La recursividad se simula

en un computador con la ayuda de una pila. Asimismo, muchos algoritmos emplean las
pilas como estructura de datos fundamental, por ejemplo, para mantener una lista de
tareas pendientes que se van acumulando.
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
Las pilas ofrecen dos operaciones fundamentales, que son apilar y desapilar sobre la
cima. El uso que se les dé a las pilas es independiente de su implementación interna.
Es decir, se hace un encapsulamiento. Por eso se considera a la pila como un tipo
abstracto de datos.
IMPORTANCIA DE LAS COLAS:
Las colas serán de ayuda fundamental para ciertos recorridos de árboles y grafos.
Las colas ofrecen dos operaciones fundamentales, que son encolar (al final de la cola)
y desencolar (del comienzo de la cola). Al igual que con las pilas, la implementación de
las colas suele encapsularse, es decir, basta con conocer las operaciones de
manipulación de la cola para poder usarla, olvidando su implementación interna.
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
DESARROLLO DEL CÓDIGO

Clase Leer:
package calculadorapilas;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
*
* @author Diego
*/
public class Leer {
public String datoStr()
{
String sdato = "";
try
{
BufferedReader bf;
bf=new BufferedReader(new InputStreamReader(System.in));
sdato=bf.readLine();
}
catch(IOException e)
{
System.err.println("Error:" + e.getMessage());
}
return sdato;
}
public int datoInt()
{
int idato=0;
try
{ BufferedReader bf;
idato=Integer.parseInt(bf.readLine());
}
{
}
return idato;
}
public float datoFloat()
{
float fdato=0;
try
{ BufferedReader bf;
fdato=Long.parseLong(bf.readLine());
}
{
}
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
return fdato;
}
/*
Clase Igraf
import java.awt.EventQueue;
import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JTextField;
import javax.swing.SwingConstants;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
/**
*
* @author Diego
*/
public class lgraf {
private JFrame frame;
private JTextField resultado;
private JTextField operacion;
/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
lgraf window = new lgraf();
window.frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Create the application.
*/
public lgraf() {
initialize();
}
/**
* Initialize the contents of the frame.
*/
private void initialize() {
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
frame = new JFrame();

frame.setBounds(100, 100, 384, 302);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().setLayout(null);
frame.setTitle("Calculadora a Pilas");
JButton btn7 = new JButton("7");

btn7.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
operacion.setText(operacion.getText()+"7");
}
});
btn7.setBounds(23, 98, 52, 23);
frame.getContentPane().add(btn7);

}
});
btn8.setBounds(85, 98, 52, 23);

}
});
btn9.setBounds(153, 98, 52, 23);

public void actionPerformed(ActionEvent arg0) {
}
});
btn4.setBounds(23, 132, 52, 23);

}
});
btn5.setBounds(85, 132, 52, 23);

10
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
}
});
btn6.setBounds(153, 132, 52, 23);

}
});
btn1.setBounds(23, 166, 52, 23);

}
});
btn2.setBounds(85, 166, 52, 23);

}
});
btn3.setBounds(153, 166, 52, 23);

}
});
btn0.setBounds(23, 200, 52, 23);
JButton btnPunto = new JButton(".");

btnPunto.addActionListener(new ActionListener() {
operacion.setText(operacion.getText()+".");
}
});
btnPunto.setBounds(85, 200, 52, 23);
frame.getContentPane().add(btnPunto);
JButton btnDiv = new JButton("/");

btnDiv.addActionListener(new ActionListener() {
11
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
operacion.setText(operacion.getText()+"/");
}
});
btnDiv.setBounds(290, 166, 45, 23);
frame.getContentPane().add(btnDiv);
JButton btnRetro = new JButton("C");

btnRetro.addActionListener(new ActionListener() {
String cadena;
cadena=operacion.getText();
if (cadena.length()>0) {
cadena=cadena.substring(0, cadena.length()-1);
operacion.setText(cadena);
}
}
});
btnRetro.setBounds(290, 98, 45, 23);
frame.getContentPane().add(btnRetro);
JButton btnMult = new JButton("*");

btnMult.addActionListener(new ActionListener() {
operacion.setText(operacion.getText()+"*");
}
});
btnMult.setBounds(290, 132, 45, 23);
frame.getContentPane().add(btnMult);
JButton btnReset = new JButton("CE");

btnReset.addActionListener(new ActionListener() {
operacion.setText("");
resultado.setText("");
}
});
btnReset.setBounds(153, 200, 55, 23);
frame.getContentPane().add(btnReset);
JButton btnResta = new JButton("-");

btnResta.addActionListener(new ActionListener() {
operacion.setText(operacion.getText()+"-");
}
});
btnResta.setBounds(215, 166, 65, 23);
frame.getContentPane().add(btnResta);
JButton btnResul = new JButton("=");

btnResul.addActionListener(new ActionListener() {
String ope = operacion.getText();
listaSimNor exArit=new listaSimNor();
12
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
String preparado=exArit.preparaCadena(ope);
exArit.llenaLista(preparado);
boolean a=exArit.valida();
if (a==true){
exArit.resolver(a);
String resu=exArit.resolver(a);
resultado.setText(resultado.getText()+resu);
}
else{
resultado.setText(resultado.getText()+"Operacion no Válida");
}
}
});
btnResul.setBounds(290, 200, 45, 23);
frame.getContentPane().add(btnResul);
JButton btnSuma = new JButton("+");

btnSuma.addActionListener(new ActionListener() {
operacion.setText(operacion.getText()+"+");
}
});
btnSuma.setBounds(215, 200, 65, 23);
frame.getContentPane().add(btnSuma);
resultado = new JTextField();

resultado.setBounds(23, 41, 312, 30);
frame.getContentPane().add(resultado);
resultado.setColumns(10);
operacion = new JTextField();

operacion.setHorizontalAlignment(SwingConstants.RIGHT);
operacion.setBounds(23, 10, 312, 30);
frame.getContentPane().add(operacion);
operacion.setColumns(10);
JButton btnPIzq = new JButton("(");

btnPIzq.addActionListener(new ActionListener() {
operacion.setText(operacion.getText()+"(");
}
});
btnPIzq.setBounds(215, 98, 67, 23);
frame.getContentPane().add(btnPIzq);
JButton btnPDer = new JButton(")");

btnPDer.addActionListener(new ActionListener() {
operacion.setText(operacion.getText()+")");
13
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
}
});
btnPDer.setBounds(215, 132, 65, 23);
frame.getContentPane().add(btnPDer);
JButton btnsebas = new JButton("*10");

btnsebas.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
}
});
btnsebas.setBounds(144, 234, 89, 23);
frame.getContentPane().add(btnsebas);
}
Clase listaSimNor
/**
*
* @author Diego
*/
public class listaSimNor extends pilaExpre {
private nodoExpN p;
public listaSimNor() {
// TODO Auto-generated constructor stub
p=null;
}
public boolean esVacia(){

boolean x=p==null ? true: false;
return x;
}
public nodoExpN getp(){

return p;
}
public void adiprimero (String it)

{ nodoExpN x = new nodoExpN();
x.setNum(it);
x.setSig(getp());
p= x;
}
public nodoExpN posicion(int pos)

{ int i;
14
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
nodoExpN q= getp();
for(i=1;i<=pos-2;i++)
{ q= q.getSig();}
return(q);
}
public void adiultimoEA(String it)

{ nodoExpN x = new nodoExpN();
x.setNum(it);
if(esVacia())
{
adiprimero(it);
}
else
{ nodoExpN q=posicion(contar()+1);
q.setSig(x);
}
}
public int contar()

{ int c= 0;
nodoExpN q= getp();
while(q!=null)
{ c++;
q= q.getSig();
}
return(c);
}
public void mostrar()

{
nodoExpN q= getp();
String it;
while(q!=null){
it= q.getNum();
//System.out.print("Dato: "+it);
q= q.getSig();
}
}
//-----------------------------metodos para realizar la

calculadora-------------
String preparaCadena(String ExpreAr){

String x="";
char a=' ';
char b=' ';
for(int i=0;i<ExpreAr.length()-1;i++)
{
a=ExpreAr.charAt(i);
b=ExpreAr.charAt(i+1);
15
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
if((a=='('&&b=='-'))
{
//System.out.println("en x "+x);
x+=a;
x+='0';
}
else
{
if(a=='-'&&i==0){
x+='0';
}
x+=a;
}
}
x+=b;
//System.out.println(x);
return x;
}
boolean valida(){
nodoExpN q=getp();
int tamaño=contar();
String it;
boolean sw=true;
for(int i=1;i<=tamaño;i++)
{
it=q.getNum();
System.out.print(it);
String it2=enviaKaesimo(i+1);
if(esSigno(it)&&esSigno(it2))
{
System.out.println("operación no valida");
sw=false;
}
if(it.equals("(")&&it2.equals("(")){
sw=false;
}
if(esSigno(it)&&i==tamaño){
sw=false;
}
if(!it.equals("(")&&!it.equals(")")&&!esSigno(it)){
if(puntosDob(it)==false){
sw=false;
System.out.println("operacion no
valida");
}
}
if(tamaño==1)
sw=false;
q=q.getSig();
}
16
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
return sw;
}
boolean puntosDob(String it){
char a=' ';
int cont=0;
boolean aux=true;
for(int i=0;i<it.length()-1;i++){
a=it.charAt(i);
if(a=='.'){
cont++;
}
}
if(cont>1)
aux=false;
return aux;
}
boolean esNumero(String x)//compara si es numero
{
boolean k=false;
if(x.equals("0")||x.equals("1")||x.equals("2")||x.equals("3")||x
.equals("4")||x.equals("5")||x.equals("6")||x.equals("7")||x.equals("8
")||x.equals("9")||x.equals(".")){
k=true;
}
return k;
}
void llenaLista(String expreAr)

{
String x;
String insert="";
expreAr=expreAr+" ";
for(int i=0;i<expreAr.length()-1;i++)
{
x=expreAr.substring(i+1, i+2);
//recupera los datos siguientes de la cadena
if(esNumero(x)&&(esNumero(expreAr.substring(i,
i+1)))) //si es numero se concatena
insert+=expreAr.substring(i,i+1);
else
//si no es numero no se concatena
{
insert+=expreAr.substring(i,i+1);
//System.out.println("en el se "+insert);
adiultimoEA(insert);
//el numero o el simbolo se agrega a la lista
insert="";
//reiniciamos la cadena
}
}
}
17
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
void limpiar(){
p=null;
}
public String enviaKaesimo(int k){ //metodo parecido a

elimina kaesimo
int conta=1;
String it= new String();
nodoExpN q=getp();
boolean sw=true;
while(q!=null&&sw==true){
if(k==conta){
it=q.getNum();
sw=false;
q=q.getSig();
}
else{
conta++;
q=q.getSig();
}
}
return(it);
}
public listaSimNor aLista(pilaExpre p){ //paso los datos de una
pila a una lista
pilaExpre aux=new pilaExpre();
listaSimNor l=new listaSimNor();
while(!p.esvacia()){
aux.insertar(p.eliminar());
}
while(!aux.esvacia())
{
l.adiultimoEA(aux.eliminar());
}
return l;
}
boolean esSigno(String x){
boolean k=false;
if(x.equals("+")||x.equals("-
")||x.equals("*")||x.equals("/"))
{
k=true;
}
return k;
}
String operacionP(listaSimNor p) //hace la operacion
{
String k="";
pilaExpre total=new pilaExpre();
float a=1;
float b=1;
int tamaño=p.contar();
nodoExpN q=getp();
18
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
{
b=1;
if(esSigno(p.enviaKaesimo(i)))
{
k=p.enviaKaesimo(i+1);
if(p.enviaKaesimo(i).equals("-"))
{
b=-1;
}
a=Float.parseFloat(total.eliminar())+(Float.parseFloat(k)*b);
i=i+1;
}
else
{
a=Float.parseFloat(p.enviaKaesimo(i));
}
total.insertar(Float.toString(a));
q=q.getSig();
}
k=total.eliminar();
return k;
}
String operacionl(listaSimNor l){ //realiza las
operaciones en los parentesis
pilaExpre p=new pilaExpre();
listaSimNor w=new listaSimNor();
String k="";
String s="";
float a;
float b=1;
int tamaño=l.contar();
nodoExpN q=l.getp();
{
k=l.enviaKaesimo(i);
if(k.equals("*")||k.equals("/"))
{
b=1;
a=Float.parseFloat(p.eliminar());
s=l.enviaKaesimo(i+1);
if(s.equals("-")){
b=-1;
s=l.enviaKaesimo(i+2);
i=i+2;
}
else
{
i++;
}
if(k.equals("*"))
{
a*=(Float.parseFloat(s)*b);
19
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
}
else{
a/=(Float.parseFloat(s)*b);
}
k=Float.toString(a);
}
q=q.getSig();
p.insertar(k);
}
w=aLista(p); //envia la suboperacion () y final
y convierte de pila a lista
s=operacionP(w); //opera si existe una suboperacion
return s;
}
String resolver(boolean a) //separa por operaciones, envi a
operacionl y muestra el resultado
{
String resultado;
String it="";
nodoExpN q=getp();
int tamaño=contar();
pilaExpre pila=new pilaExpre();
pilaExpre pila2=new pilaExpre();
listaSimNor p=new listaSimNor();
p.limpiar();
if(a==true){
{
it=enviaKaesimo(i);
if(it.equals(")"))
{
p.limpiar();
it=pila.eliminar();
while(!it.equals("("))
{
pila2.insertar(it);
it=pila.eliminar();
}
while(!pila2.esvacia())
{
p.adiultimoEA(pila2.eliminar());
}
it=operacionl(p);
pila.insertar(it);
p.limpiar();
}
else{
pila.insertar(it);
}
q=q.getSig();
}
} //fin de la validacion
while(!pila.esvacia())
{
20
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
pila2.insertar(pila.eliminar());
}
while(!pila2.esvacia())
{
p.adiultimoEA(pila2.eliminar());
}
//System.out.println(operacionl(p));
resultado=operacionl(p);
return resultado;
}
Clase nodoExpN
/**
*
* @author Diego
*/
public class nodoExpN {
String num;
nodoExpN sig;
public nodoExpN() {
sig=null;
}
public String getNum() {
return num;
}
public void setNum(String it) {
num = it;
}
public nodoExpN getSig() {
return sig;
}
public void setSig(nodoExpN it) {
sig = it;
}
}
Clase pilaExpre
/**
* @author Diego
*/
public class pilaExpre {
private int n, cima;
private String [] datos;
public pilaExpre() {
21
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
n=100;
cima=-1;
datos=new String[n];
}
public boolean esvacia(){
boolean x= cima==-1 ?true:false;
return x;
}
public boolean esllena(){
boolean x= cima==n-1 ?true:false;
return x;
}
public void insertar(String x){
if(esllena()){
System.out.println("pila llena");
}
else {
cima++;
datos [cima]=x;
//System.out.println("dato entrante "+datos);
}
}
public String eliminar() {
String x="";
if(esvacia()){
//System.out.println("pila vacia");
}
else{
x=datos[cima];
cima--;
}
return x;
}
public void vaciar(pilaExpre x){
while(!x.esvacia()){
insertar(x.eliminar());
}
}
public void mostrar(){

String x;
pilaExpre aux=new pilaExpre();
while (!esvacia()){
x=eliminar();
aux.insertar(x);
}
vaciar(aux);
}
public int cantDatos(){
return cima;
}
22
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
RESULTADOS
23
Descargado
by JOSE SantanaDE
YARANGA Palacios
lOMoARcPSD|4159588
lOMoARcPSD|16672918
CONCLUSIONES
• Con la culminación de este proyecto nos pudimos dar cuenta de la importancia

que tiene el uso de listas, pilas, colas (especialmente pilas) y los diferentes
métodos de ordenamiento, ya que vienen a disminuir los problemas de
almacenamiento de datos
• Nos pudimos dar cuenta que esta estructura puede ser aplicada en multitud de
ocasiones en el área de informática debido a su simplicidad y ordenación de la
propia estructura
24
Descargado
by JOSE SantanaDE
YARANGA Palacios

Calculadora A Pilas Ed Final

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Calculadora A Pilas Ed Final

Cargado por

Copyright:

Formatos disponibles

lOMoARcPSD|16672918

Calculadora a pilas ed final

Estructura de datos (Universidad César Vallejo)

StuDocu is not sponsored or endorsed by any college or university

Calculadora A Pilas ED Final

Algoritmo y estructura de datos (Universidad Nacional Mayor de San Marcos)

StuDocu no está patrocinado ni avalado por ningún colegio o universidad.

“Año del Buen Servicio al Ciudadano”

Proyecto de Estructura de Datos:

3 de diciembre del 2017

En ciencias de la computación, una estructura de datos es una forma particular de

Diferentes tipos de estructuras de datos son adecuados para diferentes tipos

Presentamos el siguiente proyecto final asignado al curso con la intención de presentar

• Es necesario componer los números como unidades, decenas, centenas

Luego se concatena los datos y se los agrega a la lista:

Se almacena en una pila las operaciones dentro del paréntesis:

En una variable se almacena el resultado de la operación dentro la pila:

Se agrega este resultado a la lista:

Si no existe más paréntesis se hace la operación final:

Las operaciones admitidas son suma resta multiplicación y división.

Para la Interfaz gráfica se capturo el dato jtextField introducido por la ventana de la

FUNCIONES Y USOS DE LAS PILAS Y COLAS

FUNCIONES Y USOS DE LAS PILAS:

A. Se emplea en compiladores y editores de texto dirigidos por la sintaxis.

a. Las expresiones escritas en notación convencional (infija, 7 * 2 + 8)

FUNCIONES Y USOS DE LAS COLAS:

IMPORTANCIAS DE LAS PILAS Y DE LAS COLAS:

IMPORTANCIA DE LAS PILAS:

En los programas estas estructuras suelen ser fundamentales. La recursividad se simula

IMPORTANCIA DE LAS COLAS:

DESARROLLO DEL CÓDIGO

frame = new JFrame();

JButton btn7 = new JButton("7");

JButton btn8 = new JButton("8");

JButton btn9 = new JButton("9");

JButton btn4 = new JButton("4");

JButton btn5 = new JButton("5");

JButton btn6 = new JButton("6");

JButton btn1 = new JButton("1");

JButton btn2 = new JButton("2");

JButton btn3 = new JButton("3");

JButton btn0 = new JButton("0");

JButton btnPunto = new JButton(".");

JButton btnDiv = new JButton("/");

JButton btnRetro = new JButton("C");

JButton btnMult = new JButton("*");

JButton btnReset = new JButton("CE");

JButton btnResta = new JButton("-");

JButton btnResul = new JButton("=");

JButton btnSuma = new JButton("+");

resultado = new JTextField();

operacion = new JTextField();

JButton btnPIzq = new JButton("(");

JButton btnPDer = new JButton(")");

JButton btnsebas = new JButton("*10");

public boolean esVacia(){

public nodoExpN getp(){

public void adiprimero (String it)

public nodoExpN posicion(int pos)

public void adiultimoEA(String it)

public int contar()

public void mostrar()

//-----------------------------metodos para realizar la