Código Colas

Clase Nodo

package colas;

public class Nodo {
    
    private int valor;
    // Atributo para enlazar los nodos.
    private Nodo siguiente;
     
    int prioridad;
 
    Nodo(int valor, int prioridad) {
       this.valor=valor;
       this.prioridad=prioridad;
    }
 
    Nodo() {
        
    }
     
    public void Nodo(){
        this.valor = 0;
        this.siguiente = null;
    }
 
    public int getValor() {
        return valor;
    }
 
    public void setValor(int valor) {
        this.valor = valor;
    }
 
    public Nodo getSiguiente() {
        return siguiente;
    }
 
    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }
 
    @Override
    public String toString() {
        return "Nodo{" + "valor=" + valor + ", prioridad=" + prioridad + '}';
    }
}

Clase Lista

package colas;

public class Lista {
    
    private Nodo inicio;
    // Puntero que indica el final de la lista o el ultimo nodo.
    private Nodo ultimo;
 
    public void Lista() {
        inicio = null;
        ultimo = null;
    }
 
 
 
    public void agregar(int valor, int prioridad) {
        Nodo nuevo = new Nodo(valor, prioridad);
 
        if (inicio == null) {
            inicio = ultimo = nuevo;
        } else {
 
            if (inicio.prioridad > prioridad) {
                nuevo.setSiguiente(inicio);
                inicio=nuevo;
            }else{
              Nodo ant=null;
              Nodo sig=inicio;
              while(sig!=null && prioridad>=sig.prioridad){
                  ant=sig;
                  sig=sig.getSiguiente();
              }
              nuevo.setSiguiente(sig);
              ant.setSiguiente(nuevo);
              if(sig==null){
                 ultimo=nuevo;
              }
             
            }
 
        }
    }
 
    void imprimir() {
        Nodo aux = inicio;
        do {
            System.out.println("" + aux);
            aux = aux.getSiguiente();
        } while (aux != null);
 
    }
 
}

Clase Principal

package colas;

public class Principal {

    public static void main(String[] args) {
        
        Lista ls=new Lista();
        System.out.println("Agrego nodo (100) cualquier prioridad (2)");
        ls.agregar(100, 2);
        System.out.println("Agrego nodo (200) prioridad igual al primer nodo (2)");
        ls.agregar(200, 2);
        ls.imprimir();
        System.out.println("Agrego nodo (300) prioridad 1");
        ls.agregar(300, 1);
        ls.imprimir();
        System.out.println("Agrego nodo (400) de prioridad final");
        ls.agregar(400, 3);
        ls.imprimir();
    }
    
}

Resultado

Colas

Definición 

Una cola al mismo modo de una pila  tiene como característica  principal el agregar elementos o el quitarlos por sus extremos

Las colas sirven como un medio para almacenar información creando una secuencia de datos para posteriormente  sacarla,  tiene los mismos métodos fundamentales que una pila sin embargo a diferencia de ella al momento de recuperar la información guardada se utiliza una estructura de tipo FIFO.
El tener una recuperación de datos de tipo FIFO  quiere decir que al crear la secuencia de elementos guardados el primer elemento en ser guardado va a ser el primer elemento en ser recuperado y de igual forma los siguientes datos.

Un ejemplo funcional de cola en la vida diaria es una cola de autos que esperan por pagar el peaje, el primer auto que entra es el primer auto en pagar

Estructura de Colas

Mapa Conceptual

Ejemplo:

Video

Colas con Prioridad

Una cola con prioridades es un tipo  de cola que tiene datos abstractos similares a una cola en en el cual los elemento tienen una prioridad que ha sido asignada anteriormente por el programador. Cuando tenemos una cola con prioridades el dato o elemento que presente  una mayor prioridad va a ser sacado o desencolado antes de un elemento que presente menor prioridad sin importar el orden en el cual fueron ingresados.

Cuando en una cola tenemos dos elementos con igual grado de prioridad los dos elementos se van desencolaran siguiendo el orden de cola en el cual fueron ingresados.

Codigo de Expresiones

Ejemplo 1

Clase Pila

package Expresiones_Pila;

public class Pila {

    private int pila[];
    private int dato;
    private int tope = -1;
    private int max = 0;
    private boolean res;

    Pila(int max) {//el constructor pide el tamano de la pila
        this.max = max;
        pila = new int[max];//se crea un arreglo del tamano pasado ateriormente
        dato = 0;
    }

    public void borrarpila() {//metodo para borrar toda la pila
        tope = -1;//mandamos el tope al principio, esto indica que la pila esta vacia
    }

    public boolean Pila_llena() {
        if (tope == (max - 1)) {
            res = true;
        } else {
            res = false;
        }

        return res;
    }

    public boolean Pila_vacia() {
        if (tope == -1) {
            res = true;
        } else {
            res = false;
        }

        return res;
    }

    public boolean poner(int dato) {
        if (Pila_llena()) {
            System.err.print("Desbordamiento: Pila llena");
        } else {
            tope++;
            pila[tope] = dato;
            res = true;
        }
        return res;
    }

    public int quitar() {
        
        if (Pila_vacia()) {
            System.err.print("Sub-Desbordamiento: Pila vacia");
        } else {
            dato = pila[tope];
            tope--;
        }
        return dato;
    }

    public void mostrar() {
        for (int i = tope; i >= 0; i--) {
            System.out.println(pila[i]);
        }
    }

    public String copiarPila(Object[] pila) {
        Object[] copy = new Object[pila.length];
        String muestra = "";
        System.arraycopy(pila, 0, copy, 0, pila.length);
        for (int i = 0; i < copy.length; i++) {
            muestra += copy[i] + " ";
        }
        return muestra;
    }
}

Clase Expresiones

package Expresiones_Pila;

import java.util.*;

public class Expresiones {

    private int sacaTope, sacaSig, resultado;
    private ArrayList  operadores;
    private Pila pilaPost;
    private Pila pilaPre;

    public Expresiones(String expresionPost[], String expresionPre[]) {
        pilaPost = new Pila(expresionPost.length);
        pilaPre = new Pila(expresionPre.length);

    }

    public void Postfija(String[] expresionPost) {//evalua una expresion dada en forma Postfija
        operadores = new ArrayList<>();//guardamos los operadores en una lista
        operadores.add("+");
        operadores.add("-");
        operadores.add("*");
        operadores.add("/");
        operadores.add("^");

        for (String car : expresionPost) {//recorremos la expresion con una variable tipo String
            if (operadores.contains(car)) {//si encontramos un operador de los listados antes entonces 
                sacaTope = pilaPost.quitar();//saca el tope
                //System.out.println("sacaTope: " + sacaTope);
                sacaSig = pilaPost.quitar();//luego saca el siguiente del tope
                //System.out.println("sacaSig: " + sacaSig);
                //System.out.println("car: " + car);
                operacionPost(sacaTope, sacaSig, car);//y realiza las operaciones que corresponden
            } else {//si encuentra un operando, lo agrega directamente a la pila
                pilaPost.poner(Integer.parseInt(car));
                //System.out.println("entra: " + car);
            }
            //pilaPost.mostrar();
        }
        pilaPost.mostrar();//mostramos el elemento que queda en la pila
    }

    public void Prefija(String[] expresionPre) {//evalua una expresion dada en forma Prefija 
        String car;
        operadores = new ArrayList<>();
        operadores.add("+");
        operadores.add("-");
        operadores.add("*");
        operadores.add("/");
        operadores.add("^");

        for (int i = (expresionPre.length - 1); i >= 0; i--) {//recorremos la expresion en oreden inverso a la anterior 
            car = expresionPre[i];//guardamos los caracteres en una variable, para despues utilizarlos
            if (operadores.contains(car)) {
                sacaTope = pilaPre.quitar();
//                System.out.println("sacaTope: " + sacaTope);
                sacaSig = pilaPre.quitar();
//                System.out.println("sacaSig: " + sacaSig);
//                System.out.println("car: " + car);
                operacionPre(sacaTope, sacaSig, car);
            } else {
                pilaPre.poner(Integer.parseInt(car));
//                System.out.println("entra: " + car);
            }
//            pilaPre.mostrar();
        }
        pilaPre.mostrar();
    }

    public int operacionPost(int sacaTope, int sacaSig, String operador) {//calcula la expresion en Postfija
        if (operador.equals("^")) {
            resultado = (int) Math.pow(sacaSig, sacaTope);
            pilaPost.poner(resultado);
        } else if (operador.equals("/")) {
            resultado = sacaSig / sacaTope;
            pilaPost.poner(resultado);
        } else if (operador.equals("+")) {
            resultado = (sacaSig + sacaTope);
            pilaPost.poner(resultado);
        } else if (operador.equals("-")) {
            resultado = sacaSig - sacaTope;
            pilaPost.poner(resultado);
        } else if (operador.equals("*")) {
            resultado = sacaSig * sacaTope;
            pilaPost.poner(resultado);
        }
        return resultado;
    }

    public int operacionPre(int sacaTope, int sacaSig, String operador) {//calcula la expresion en Prefija
        if (operador.equals("^")) {
            resultado = (int) Math.pow(sacaTope, sacaSig);
            pilaPre.poner(resultado);
        } else if (operador.equals("/")) {
            resultado = sacaTope / sacaSig;
            pilaPre.poner(resultado);
        } else if (operador.equals("+")) {
            resultado = (sacaTope + sacaSig);
            pilaPre.poner(resultado);
        } else if (operador.equals("-")) {
            resultado = sacaTope - sacaSig;
            pilaPre.poner(resultado);
        } else if (operador.equals("*")) {
            resultado = sacaTope * sacaSig;
            pilaPre.poner(resultado);
        }
        return resultado;
    }
}

Clase Principal

package Expresiones_Pila;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Principal {

    private static String expresionPost[] = {"6", "2", "3", "+", "-","3","8","2","/","+","*","2","^","3","+"};
    private static String expresionPre[] = {"+", "2", "*", "3", "1"};
    private static Expresiones exp;

    public static void main(String args[]) {
        exp = new Expresiones(expresionPost, expresionPre);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int des = 0;
        try {
            System.out.println("Calcular: \n1.-Postfija\n2.-Prefija");
            des = Integer.parseInt(br.readLine());
        } catch (IOException e) {
            System.out.println("Se esperaba un numero: " + e.getCause());
        }
        if (des == 1) {
            System.out.print("Evaluar: ");
            mostrarExpPost();
            System.out.print("\nResultado: ");
            exp.Postfija(expresionPost);
        } else if (des == 2) {
            System.out.print("Evaluar: ");
            mostarExpPre();
            System.out.print("\nResultado: ");
            exp.Prefija(expresionPre);

        }
    }

    public static void mostrarExpPost() {//muestra la expresion Postfija 
        for (int i = 0; i < expresionPost.length; i++) {
            System.out.print(expresionPost[i]);
        }
    }

    public static void mostarExpPre() {//muestra la expresion Prefija
        for (int i = 0; i < expresionPre.length; i++) {
            System.out.print(expresionPre[i]);
        }
    }
}

Ejemplo 2

public class Pilas {
 
 public static void main(String[] args) {
  String text = JOptionPane.showInputDialog("Dame infijo :");
  System.out.println("Prefijo : "+ Infijo2PrefijoTxt(text));
 }
 public static String Infijo2PrefijoTxt(String infijo){
  Pila p1 = Infijo2Prefijo(infijo);
  String text = "";
  while (p1.i > 0)
   text += p1.pop();
  return text;
 
 }
 
 public static Pila Infijo2Prefijo(String infijo) {
  infijo = '(' + infijo ; // Agregamos al final del infijo un ')'
  int tamaño = infijo.length();
  Pila PilaDefinitiva = new Pila(tamaño);
  Pila PilaTemp = new Pila(tamaño);
  PilaTemp.push(')'); // Agregamos a la pila temporal un '('
  for (int i = tamaño-1; i > -1; i--) {
   char caracter = infijo.charAt(i);
   switch (caracter) {
   case ')':
    PilaTemp.push(caracter);
    break;
   case '+':case '-':case '^':case '*':case '/':
    while (Jerarquia(caracter) > Jerarquia(PilaTemp.nextPop()))
     PilaDefinitiva.push(PilaTemp.pop());
    PilaTemp.push(caracter);
    break;
   case '(':
    while (PilaTemp.nextPop() != ')')
     PilaDefinitiva.push(PilaTemp.pop());
    PilaTemp.pop();
    break;
   default:
    PilaDefinitiva.push(caracter);
   }
  }
  return PilaDefinitiva;
 }
 
 public static int Jerarquia(char elemento) {
  int res = 0;
  switch (elemento) {
  case ')':
   res = 5; break;
  case '^':
   res = 4; break;
  case '*': case '/':
   res = 3; break;
  case '+': case '-':
   res = 2; break;
  case '(':
   res = 1; break;
  }
  return res;
 }
}

Resultado 1

Resultado 2

Codigo de Pilas

Clase Nodo

package PilasNodos;


public class Nodo {
    
    private Integer dato;
    private Nodo siguiente;

    public Nodo(Integer dato) {
        this.dato = dato;
        siguiente=null;
    }

    public Nodo(Integer dato, Nodo siguiente) {
        this.dato = dato;
        this.siguiente = siguiente;
    }

    public Integer getDato() {
        return dato;
    }

    public void setDato(Integer dato) {
        this.dato = dato;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }
    
    
    
}

Clase Pila

package PilasNodos;

public class Pila {
    
    private Nodo inicio;

    public Pila() {
        inicio=null;
    }
    
    public void Push(Integer dato){
        Nodo nuevo =new Nodo(dato);
        
        if(inicio==null){
            
            inicio=nuevo;
        }           
        else{
            nuevo.setSiguiente(nuevo);
            inicio=nuevo;
        }
        System.out.println("El inicio: " + nuevo.getDato());
    }
    
    public Integer Pop(){
        
        Nodo aux=inicio;
        inicio=inicio.getSiguiente();
        aux.setSiguiente(null);
        Integer resultado=aux.getDato();
        aux=null;
        
        System.out.println("Se elimina el: " + resultado);
        return resultado;
    }
    
    
    
    
}

Clase Principal

package PilasNodos;

public class Principal {

    public static void main(String[] args) {
        
        Pila coleccion=new Pila();
        
        coleccion.Push(16);
        coleccion.Push(67);
        coleccion.Push(13);
        
        
        coleccion.Pop();
    }
    
}

Resultado

Tratamiento de Expresiones

Definición 
El tratamiento de expresiones es un método  en la cual  se apoya el programador para expresar términos que son computables y que regresan algún tipo de valor.

Si queremos realizar una comprobación del resultado se debe realizar una comprobación en el cual se toma en cuenta los datos que tenemos y los operandos para así evaluar los resultados

Si dentro de nuestra expresión tenemos más de un operador debemos realizar una evaluación de operadores los operadores que tenemos, identificando los de mayor prioridad

Expresión Infija

·         Es la notación que más se utiliza para escribir expresiones matemáticas

·         La expresión infija se caracteriza debido a que el los operadores de la expresión dada se encuentran entre sus operandos

·         En varias ocasiones en este tipo de expresión se necesita de la ayuda del paréntesis para indicar el orden en el cual se debe efectuar la operación

Expresión Prefija

·         El enunciado principal de esta notación nos explica que el operador va antes de los operandos

·         Esta expresión se dio con la finalidad de poder especificar el orden en el cual se realizan las operaciones sin necesidad de usar el paréntesis para que indique el orden en el que se va a operar

·         Se realiza una evaluación de orden izquierda a derecha hasta encontrar el primer operador con  un par de operandos. 
                                          

Expresión Postfija

·         Esta clase de notación apareció al hacer una clase de variación de la notación prefija

·         Se caracteriza por el orden en el que se coloca el operador ya que ocupa una posición después de los operandos
ll

     

Ejemplos:

Pilas

Definición 

Una pila es un tipo de estructura de datos  cuya característica fundamental es la de agregar o quitar elementos por  a través de uno de sus dos extremos. 

La estructura de una pila es la de agregar elementos en forma de una lista ordenada de igual forma me permite almacenar y recuperar datos, la recuperación de datos es de tipo LIFO (último en entrar, primero en salir)

Para poder manejar los datos que se ingresan cuenta con dos operaciones básicas, la de apilar los elementos que coloca un objeto uno detrás de otro y su operación inversa, el de retirar elementos que selecciona los objetos a salir desde el final de la pila.

Un ejemplo de sobre cómo funciona una pila son las ventanas de Windows, cuando cerramos  una ventana recuperamos la de atrás. De igual forma se puede representar con un bloque de libros.


Estructura de una Pila

Mapa Conceptual 

Video