Evaluar expresión Postfija usando pilas.

Codigo:

// Evaluar expresión en notación Postfija (solo num enteros)
package evalpost;

import java.util.Stack;

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

    //Añadir post (array) a la Pila de entrada (E)
    for (int i = post.length - 1; i >= 0; i--) {
      E.push(post[i]);
    }

    //Algoritmo de Evaluación 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:
    System.out.println("Expresion: " + expr);
    System.out.println("Resultado: " + P.peek());

  }

  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;
  }

}


Resultado:

run:
Expresion: 2 23 6 + * 1 -
Resultado: 57
BUILD SUCCESSFUL (total time: 0 seconds)

.

Conversión de Infijo a Postfijo usando pilas

Ver referencia: Infijo-Posfijo


Codigo:

//Conversión de notación Infija a Postfija mediante uso de pilas
package infixpostfix4;

import java.util.Scanner;
import java.util.Stack;

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

    //Entrada de datos
    System.out.println("*Escribe una expresión algebraica: ");
    Scanner leer = new Scanner(System.in);

    //Depurar la expresion algebraica
    String expr = depurar(leer.nextLine());
    String[] arrayInfix = expr.split(" ");

    //Declaración de las pilas
    Stack < String > E = new Stack < String > (); //Pila entrada
    Stack < String > P = new Stack < String > (); //Pila temporal para operadores
    Stack < String > S = new Stack < String > (); //Pila salida

    //Añadir la array a la Pila de entrada (E)
    for (int i = arrayInfix.length - 1; i >= 0; i--) {
      E.push(arrayInfix[i]);
    }

    try {
      //Algoritmo Infijo a Postfijo
      while (!E.isEmpty()) {
        switch (pref(E.peek())){
          case 1:
            P.push(E.pop());
            break;
          case 3:
          case 4:
            while(pref(P.peek()) >= pref(E.peek())) {
              S.push(P.pop());
            }
            P.push(E.pop());
            break; 
          case 2:
            while(!P.peek().equals("(")) {
              S.push(P.pop());
            }
            P.pop();
            E.pop();
            break; 
          default:
            S.push(E.pop()); 
        } 
      }

      //Eliminacion de `impurezas´ en la expresiones algebraicas
      String infix = expr.replace(" ", "");
      String postfix = S.toString().replaceAll("[\\]\\[,]", "");

      //Mostrar resultados:
      System.out.println("Expresion Infija: " + infix);
      System.out.println("Expresion Postfija: " + postfix);

    }catch(Exception ex){ 
      System.out.println("Error en la expresión algebraica");
      System.err.println(ex);
    }
  }

  //Depurar expresión algebraica
  private static String depurar(String s) {
    s = s.replaceAll("\\s+", ""); //Elimina espacios en blanco
    s = "(" + s + ")";
    String simbols = "+-*/()";
    String str = "";
 
    //Deja espacios entre operadores
    for (int i = 0; i < s.length(); i++) {
      if (simbols.contains("" + s.charAt(i))) {
        str += " " + s.charAt(i) + " ";
      }else str += s.charAt(i);
    }
    return str.replaceAll("\\s+", " ").trim();
  }

  //Jerarquia de los operadores
  private static int pref(String op) {
    int prf = 99;
    if (op.equals("^")) prf = 5;
    if (op.equals("*") || op.equals("/")) prf = 4;
    if (op.equals("+") || op.equals("-")) prf = 3;
    if (op.equals(")")) prf = 2;
    if (op.equals("(")) prf = 1;
    return prf;
  }
}


Resultado:

run:
*Escribe una expresión algebraica:
2*(23+6)-1
Expresion Infija: (2*(23+6)-1)
Expresion Postfija: 2 23 6 + * 1 -
BUILD SUCCESSFUL (total time: 4 seconds)

Primeros pasos para conversión notación Infija a Postfija.

La notación Postfija es un método algebraico alternativo de introducción de datos que permite reducir el acceso a la memoria del ordenador, sobretodo en calculos masivos y complejos ya que los cálculos se realizan secuencialmente según se van introduciendo los operadores (en vez de tener que esperar a escribir la expresión al completo).
Basicamente consiste en que en una expresión de ese tipo primero están los operandos y después viene el operador.

Ej:

         "3+5" pasado a notación Postfija seria: "3 5 +"

* Pasos para la conversión Infijo a Postfijo usando pilas.  

     EXPR = Expresión aritmética notación infija ( Ej: 2*(23+6)-1 )

     E = pila de entrada
     P = pila temporal para los operadores
     S = pila de salida  

1.- Añadir “(” al principio y “)” al final de EXPR. Seguidamente agregar uno a uno todos los parametros de EXPR a la Pila E.

(,2,*,(,23,+,6,),-,1,)

2.- Examinar E de izquierda a derecha y repetir los pasos 3 a 6 para cada elemento de E hasta que esta quede vacía.

3.- Si se encuentra “(”, meterlo en P.

4.- Si se encuentra un OPERADOR (+,-,*,/,^) entonces:

     (a) Repetidamente sacar de P y añadir a S cada operador (de la cima de P) que tenga la misma precedencia o mayor que el operador de E.

     (b) Añadir OPERADOR a P.

[Fin de condicional]

5.- Si se encuentra un “)”, entonces:

     (a) Repetidamente sacar de P y añadir a S cada operador (de la cima de P), hasta que encuentre un “(”.

     (b) Eliminar el “(” de P (no añadir a S).

[Fin de condicional]

6.- Si se encuentra un OPERANDO (2,23,6…), añadirlo a S.

[Fin del Bucle]

7.- Salir.

Nota: Los operadores siguen la siguiente jerarquía (El de arriba es el que tiene mayor jerarquía hasta abajo el que tiene la menor): 

1. ^
2. *  /
3. +  -
4. )
5. (

* Diagrama de flujo:

Pilas: Comandos básicos (push, pop, peek, empty)

Codigo:

//Pilas: Comandos basicos (push, pop, peek, empty)
package pilas;

import java.util.Stack;

public class Pilas {   

    public static void main(String[] args) {

        Stack < String > pila = new Stack < String > ();
       
        //apila 3 elementos
        pila.push("elemento1");
        pila.push("elemento2");
        pila.push("elemento3");
        System.out.println("1- push: " + pila);
       
        //retira elemento que esta en la cima de la pila
        pila.pop();
        System.out.println("2- pop: " + pila);
       
        //devuelve el elemento que esta en la cima de la pila
        String x = pila.peek();
        System.out.println("3- peek: " + x);
       
        //devuelve cierto si la pila esta vacia
        boolean y = pila.empty();
        System.out.println("4- empty: " + y);

    }
}

Resultado:

run:
1- push: [elemento1, elemento2, elemento3]
2- pop: [elemento1, elemento2]
3- peek: elemento2
4- empty: false
BUILD SUCCESSFUL (total time: 0 seconds)

Pilas: Apliar/Desapilar palabras en una pila.

Codigo:

//Pilas: Apilar/Desapilar strings
package pilas;

import java.util.Stack;

public class Pilas {
    public static void main(String[] args) {
        //Crear pila (en inglés Stack) para datos de tipo String.
        Stack < String > pila = new Stack < String >();
       
        //apliando en la pila
        pila.push("primero");
        System.out.println("\nIr apilando:\n" + pila);
        pila.push("segundo");
        System.out.println(pila);
        pila.push("tercero");
        System.out.println(pila);
       
        //desapilando en la pila
        pila.pop();
        System.out.println("\nIr desapilando:\n" + pila);
        pila.pop();
        System.out.println(pila);
        pila.pop();
        System.out.println(pila);
       
    }
}

Resultado:

run:

Ir apilando:
[primero]
[primero, segundo]
[primero, segundo, tercero]

Ir desapilando:
[primero, segundo]
[primero]
[]
BUILD SUCCESSFUL (total time: 0 seconds)

Permutaciones: Sin repetición / Importa orden. (forma recursiva)

Codigo:

//* Permutaciones (Forma recursiva)

//- Importa posición

//- Sin repetición

//- Requisito: R >= N

package permutacion2;

public class Permutacion2 {

    public static void main(String[] args) {

        String[] elementos = "a,b,c,d,e".split(",");

        int n = 4;                  //Tipos para escoger

        int r = elementos.length;   //Elementos elegidos

        Perm2(elementos, "", n, r);

    }

    private static void Perm2(String[] elem, String act, int n, int r) {

        if (n == 0) {

            System.out.println(act);

        } else {

            for (int i = 0; i < r; i++) {

                if (!act.contains(elem[i])) { // Controla que no haya repeticiones

                    Perm2(elem, act + elem[i] + ", ", n - 1, r);

                }

            }

        }

    }

}

Resultado:

run:
a, b, c, d,
a, b, c, e,
a, b, d, c,

...

...

...

e, d, b, c,
e, d, c, a,
e, d, c, b,
BUILD SUCCESSFUL (total time: 0 seconds)

Permutaciones: Con repetición / Importa orden. (forma recursiva)

Codigo:

//* Permutaciones (Forma recursiva)
//- Importa posición
//- Con repetición
package permutacion1;

public class Permutacion1 {

    public static void main(String[] args) {
        String[] elementos = "a,b,c,d,e".split(",");
        int n = 4;                  //Tipos para escoger
        int r = elementos.length;   //Elementos elegidos

        Perm1(elementos, "", n, r);

    }

    private static void Perm1(String[] elem, String act, int n, int r) {
        if (n == 0) {
            System.out.println(act);
        } else {
            for (int i = 0; i < r; i++) {
                Perm1(elem, act + elem[i] + ", ", n - 1, r);
            }
        }
    }
}

Resultado:

run:
a, a, a, a,
a, a, a, b,
a, a, a, c,
...

...

...

e, e, e, c,
e, e, e, d,
e, e, e, e,
BUILD SUCCESSFUL (total time: 0 seconds)

Obtener el resultado numérico de una formula contenida en un string: eval.

Codigo:

 

//Obtener el resultado de una formula que esta contenida en una variable de tipo string: eval.

package formula;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class Formula {    
    public static void main(String[] args) {        
        ScriptEngineManager mgr = new ScriptEngineManager();   
        ScriptEngine engine = mgr.getEngineByName("JavaScript");       
        try {
            String formula = "5-3+6*(10/2)";
            System.out.println(formula + " = " + engine.eval(formula));
        } catch (ScriptException ex) {}
    }    
}

Resultado:

run:
5-3+6*(10/2) = 32.0
BUILD SUCCESSFUL (total time: 0 seconds)

Imprimir un jPanel y con todos sus componentes internos.

Usando el Netbeans creamos un jDialog y le agregamos un jPanel. Dentro de ese jPanel le agregamos por ejemplo una jTable, un label y un jButton. Tal y como muestra la siguiente captura:

Codigo:

//Imprimir un jPanel y con todos sus componentes internos.
package imprimir;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;

public class Impresiones extends javax.swing.JDialog implements Printable {
    public Impresiones(java.awt.Frame parent, boolean modal) {
        initComponents();
    }
    private void initComponents() {...}//aqui va codigo generado por Netbeans
    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                        
        try {
            PrinterJob job = PrinterJob.getPrinterJob();
            job.setPrintable(this);
            job.printDialog();
            job.print();
        } catch (PrinterException ex) { }       
    }

    public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                Impresiones dialog = new Impresiones(new javax.swing.JFrame(), true);
                dialog.addWindowListener(new java.awt.event.WindowAdapter() {
                    public void windowClosing(java.awt.event.WindowEvent e) {
                        System.exit(0);
                    }
                });
                dialog.setVisible(true);
            }
        });
    }
    // Variables declaration - do not modify                    
    private javax.swing.JButton jButton1;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JTable jTable1;
    // End of variables declaration                  
   
    public int print(Graphics graphics, PageFormat pageFormat, int pageIndex) throws PrinterException {
        if (pageIndex > 0) return NO_SUCH_PAGE;
        Graphics2D g2d = (Graphics2D)graphics;
        //Punto donde empezará a imprimir dentro la pagina (100, 50)
        g2d.translate(  pageFormat.getImageableX()+100,
                        pageFormat.getImageableY()+50);
        g2d.scale(0.50,0.50); //Reducción de la impresión al 50%
        jPanel1.printAll(graphics);
        return PAGE_EXISTS;               
    }
}

Resultado: