Link Log

Bueno, ya conociendo el algoritmo, se puede hacer en Java:

class converpostultima{
public static void main (String args[])
{

String expr = new String(”");
String exprpost = new String(”");
char ch;
int max;
System.out.print(”Dame la Expresion en Infijo: “);
expr =Leer.dato();
max=expr.length();
operapilaschar obj1 = new operapilaschar(max);
System.out.println();
System.out.println();
System.out.println(”La Expresion en Postfijo es :”);
obj1.push(’('); // inserta ‘(’ a la PILA
expr+=’)'; // inserta ‘)’ al final de Q
for (int i=0;i=precedencia(ch) && obj1.pila[obj1.tope]!=’('))
{
obj1.pop();
exprpost+=obj1.dret;
}
obj1.push(ch);
break;
case ‘)’: while (obj1.pila[obj1.tope] != ‘(’)
{
obj1.pop();
exprpost+=obj1.dret;
}
obj1.pop();
break;
default : exprpost+=ch;
}

}
while (!(obj1.pila_Vacia(obj1.tope)))
{
obj1.pop();
if (obj1.dret!= ‘(’)
exprpost+=obj1.dret;
}
System.out.println(exprpost);
}

public static int precedencia(char ch)
{
int aux = 0;
switch (ch)
{
case ‘^’ : aux = 4;
break;
case ‘*’ : case ‘/’ : aux = 3;
break;
case ‘+’ : case ‘-’ : aux = 2;
break;
case ‘(’ : aux = 1;
break;
}
return aux;
}
}

Cabe aclarar que el código no lo hice yo, si no que me lo pasaron para entender el algoritmo.

Bueno, ya después del programa de pilas que puse hace poco (es el articulo pasado), sigue lo de pasar una expresión infija a posfija (luego pongo la de posfija a infija) que también se hace mediante pilas, pero en esta se hace manualmente (es decir, lápiz y papel). Aquí están los pasos (algoritmo) que hay que seguir:

ALGORITMO: POLACA(Q,P). Suponemos que Q es una expresión aritmética escrita en notación infija. Este algoritmo encuentra su expresión postfija P.

1.- Meter “(” en PILA y añadir “)” al final de Q.
2.- Examinar Q de izquierda a derecha y repetir los pasos 3 a 6 para cada elemento de Q hasta que la PILA esté vacía.
3.- Si se encuentra PARÉNTESIS IZQ., meterlo en PILA.
4.- Si se encuentra un OPERADOR entonces:
(a) Repetidamente sacar de PILA y añadir a P cada operador (de la cima de PILA) que tenga la misma precedencia o mayor que el operador.
(b) Añadir OPERADOR a PILA.
[FIN de condicional]
5.- Si se encuentra un PARÉNTESIS DER., entonces:
(a) Repetidamente sacar de PILA y añadir a P cada operador (de la cima de PILA) hasta que se encuentre un paréntesis izquierdo.
(b) Eliminar el PARÉNTESIS IZQ.(no añadir el paréntesis izquierdo a P).
[Fin de condicional]
6.- Si se encuentra un OPERANDO, añadirlo a P.

[Fin del Bucle]
7.- Salir.

Los operadores siguen la siguiente jerarquía (El de arriba es el que tiene mayor jerarquía hasta abajo el que tiene la menor):
^
* /
+ -
(

Ejemplo:

A+(X/Y)*B^C

Este es un ejemplo demasiado sencillo, pero explica los pasos a seguir, y como se puede ver en la ultima fila de la tabla esta el resultado.

Este programa lo hice hace tiempo, aunque lo hice en un diagrama de flujo. Este programa hace conversiones de unidades, aunque es muy sencillo, tal vez le pueda ayudar a alguien.

Por cierto, no recuerdo bien si las medidas están correctas, por lo que si no están es fácil corregir.

import java.io.*;
import java.util.Scanner;
public class Medidas{
public static void main( String args[] ){
Scanner leer = new Scanner(System.in);

int KM;
int CM;
int Y;
int op;
double RES;

System.out.println( “Ingrese la operacion” );
System.out.println( “1.- Centimetos a pulgadas” );
System.out.println( “2.- Yardas a metros” );
System.out.println( “3.- Kilometros a millas” );
System.out.println( “\n” );
op = leer.nextInt();

switch (op){
case 1:
System.out.println( “Centimetros a pulgadas” );
System.out.println( “Ingrese los centimetros” );
CM = leer.nextInt();
RES = CM * 2.3;
System.out.println( “El resultado es: “+RES+” pulgadas” );
break;
case 2:
System.out.println( “Yardas a Metros” );
System.out.println( “Ingrese el numero de Yardas” );
Y = leer.nextInt();
RES = Y * 0.914401829;
System.out.println( “El resultado es: “+RES+” metros” );
break;
case 3:
System.out.println( “Kilometros a Millas” );
System.out.println( “Ingrese el numero de Kilometros” );
KM = leer.nextInt();
RES = KM * 0.621;
System.out.println( “El resultado es: “+RES+” millas” );
break;
}
}
}

Bueno, voy a poner el código de un programa en Java que hace uso de pilas. En este programa se le ingresa una palabra (hasta las groserías funcionan…), y separa las letras y las imprime de una en una de abaja hacia arriba:

Ejemplo: Si se escribe la palabra JAVA.
La impresión sera:
A
V
A
J

Bueno, aquí esta el código:

import java.io.*;
import java.util.Scanner;
public class PilaCadena{
public static void main( String args[] ){
Scanner leer = new Scanner(System.in);
operapilaschar Obj = new operapilaschar();

String cadena;
char ch;

System.out.println( “Escribe texto:” );
cadena = leer.next();

for( int i=0; i<cadena.length(); i++ ){
ch = cadena.charAt(i);
Obj.push(ch);
}

for( int i=0; i<cadena.length(); i++ ){
Obj.pop();
System.out.println( Obj.dret );
}
}
}

Hace uso de los métodos de la siguiente clase:

class operapilaschar

{

public static char dret;

public static int max;

public static char pila[];

public static int tope = -1;

public operapilaschar()

{

max=20;

pila=new char [max];

}

public operapilaschar(int n)

{

max=n-1;

pila = new char [max];

}

public static boolean pila_Llena(int tope,int max)

{

boolean llena;

if (tope==max)

llena=true;

else

llena=false;

return llena;

}

public static boolean pila_Vacia(int tope)

{

boolean vacia;

if (tope == -1)

vacia=true;

else

vacia=false;

return vacia;

}

public static void push(char dato)

{

if(pila_Llena(tope,max))

System.out.println(”!Cuidado!, Desbordamiento!!!!!”);

else

{

tope++;

pila[tope]=dato;// pone el nuevo dato en la pila

}

}

public static void pop()

{

if (pila_Vacia(tope))

System.out.println(”!Cuidado!, Subdesbordamiento!!!!!”);

else {

dret=pila[tope];

tope–;

}// actualiza tope y se elimina elemento en el tope

}

public static boolean compara(int dret,int ch)

{

if (dret==’(’ && ch==’)’ || dret==’{’ && ch==’}’ || dret==’[' && ch==']‘)

return true;

else

return false;

}

public static void estado()

{

int i;

System.out.println(” El estado de la pila es : “);

System.out.println(” ————————–”);

for(i=0;i<=tope;i++)

{

System.out.println(”pila["+i+"] : “+pila[i]);

}

}

}

Para los iniciados en la programación (como yo), usar un IDE grande puede resultar un tanto engorroso, ya que si solo se quiere hacer una clase no se va a querer hacer un proyecto y bla bla bla…

Es ahí cundo usaba JCreator, que si bien no es tan poderoso como NetBeans o Eclipse, cumplía con su trabajo de resaltar la sintaxis y facilitar la compilación y ejecución (si no mal recuerdo, solo se presionaba el F5), no requería gran cantidad de recursos para funcionar, solo era editar la clase, ejecutarla y listo, nada de paquetes ni proyectos (si no se quería), solo una clase y ya, como se hace cuando se esta aprendiendo.

Bueno, los usuarios de Windows no tienen ese problema, pero, ¿y los de Linux?, pues tampoco, ya que en KDE esta Kate, que si bien es un editor, puede incorporar la terminal en la parte de abajo del editor y así hacer la función de pequeño IDE, ya que resalta la sintaxis del lenguaje.

Bueno, ya esta KDE, pero, ¿y Gnome?, pues aun mas fácil, ya que solo se necesita instalar el programa Geany, que es un pequeño IDE (similar a JCreator), trae resaltado de sintaxis y un botón de compilación y otro de ejecución en la parte de arriba, se pueden hacer proyectos (si se ocupa), también en la parte de abajo incorpora la terminal para hacer compilaciones o cualquier otra cosa que se quiera hacer mientras se programa.

No digo que Eclipse o NetBeans sean malos, al contrario, el problema es que es como dicen por ahí “es como querer matar moscas a cañonazos”.

Bueno, aquí una imagen para que vean como es:

Con este programa, se creara un archivo con registros de numero de matricula, nombre y pedirá 3 calificaciones para después calcular el promedio.

import java.io.*;
import java.util.Scanner;
public class Archivos{

public static void main( String args[] )throws IOException{
Scanner leer = new Scanner(System.in);
DataOutputStream Archi = null;
int i;
int matricula=0;
String nombre=new String(”");
int calif1;
int calif2;
int calif3;
double promedio;

try{
for (i=0; i<5; i++){
Archi = new DataOutputStream( new FileOutputStream(”../Archivo.dat”,true) );
System.out.println(”Escribe la matricula: “);
matricula = leer.nextInt();
System.out.println(”Escribe Nombre: “);
nombre = leer.next();
System.out.println(”Ingrese Calificacion 1: “);
calif1 = leer.nextInt();
System.out.println(”Ingrese Califiación 2″);
calif2 = leer.nextInt();
System.out.println(”Ingrese Calificacion 3″);
calif3 = leer.nextInt();

Archi.writeInt(matricula);
Archi.writeUTF(nombre);
Archi.writeInt(calif1);
Archi.writeInt(calif2);
Archi.writeInt(calif3);
Archi.close();
}
}
catch(FileNotFoundException fnfe) {}
catch (IOException ioe) {}
}
}

Este otro mostrara lo que hay en el archivo:

import java.io.*;
public class LeerArchivos{

public static void main( String args[] )throws IOException{

DataInputStream Archi = null;

int matricula=0;
String nombre=new String(”");
int calif1;
int calif2;
int calif3;
double promedio;

try{
Archi = new DataInputStream( new FileInputStream(”../Archivo.dat”) );
while (true){
matricula = Archi.readInt();
System.out.println(”Matricula: “+matricula+” “);
nombre = Archi.readUTF();
System.out.println(”Nombre: “+nombre+” “);
calif1= Archi.readInt();
System.out.println(”Calificacion 1: “+calif1+” “);
calif2= Archi.readInt();
System.out.println(”Calificacion 2: “+calif2+” “);
calif3= Archi.readInt();
System.out.println(”Calificacion 3: “+calif3+” “);
System.out.println(’n');

int suma = calif1 + calif2 + calif3;
promedio = suma/3;

System.out.println(”El promedio es: “+promedio+”n”);
}
}

catch(FileNotFoundException fnfe) {}
catch (IOException ioe) {}

Archi.close();

}
}

En este programa pide que ingreses el nombre del trabajador, el puesto y lo que gana, después en otro método imprime los datos que se ingresaron, pero primero pregunta al usuario si los quiere imprimir.


import java.util.Scanner;
import java.io.*;
public class empleado{

public static void main( String args[] ){
capturar();
}
}


Capturar el nombre y las 3 calificaciones en el programa principal (método main), calcular promedio en un segundo metodo, imprimir nombre y promedio en otro método.


import java.util.Scanner;
import java.io.*;
public class Calificaciones{

System.out.println( “El promedio de “+nom + “es: “+prom );
}
}