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

Llega iOS 8.3, Repleto de mejoras

Todas las novedades de IOS 8.3

Mejoras en la conectividad de Wi-Fi y Bluetooth 

• Solución de un problema que provocaba que se solicitaran constantemente las credenciales de inicio de sesión del usuario.
• Corrección de un problema que causaba la desconexión intermitente de algunos dispositivos de las redes Wi-Fi a las que estaban conectados.
• Solución de un problema que ocasionaba la desconexión de las llamadas de teléfono con manos libres.
• Solución de un problema que hacía que la reproducción de audio dejara de funcionar con algunos altavoces Bluetooth.

Mejoras en Mensajes 

• Corrección de los problemas que a veces provocaban que los mensajes de grupo se dividieran.

• Solución de un problema que ocasionaba que en ocasiones no se pudieran reenviar o eliminar algunos mensajes.

• Resolución de un problema que a veces impedía la aparición de la previsualización de una foto tomada en Mensajes.

• Posibilidad de marcar los mensajes como no deseados directamente desde la aplicación Mensajes.

• Posibilidad de filtrar los mensajes de iMessage que no ha enviado ninguno de sus contactos.

Mejoras de CarPlay 

• Solución de un problema que causaba que la pantalla de Mapas apareciera en negro.

• Solución de un problema que provocaba la rotación incorrecta de la interfaz de usuario.

• Solución de un problema que hacía que el teclado apareciera en la pantalla de CarPlay cuando no debía.

Mejoras en la orientación y la rotación

 

• Corrección de un problema que en ocasiones impedía a la pantalla volver a la orientación vertical después de haber girado a la orientación horizontal.

• Mejora de los problemas de funcionamiento y estabilidad que ocurrían al cambiar la orientación del dispositivo de horizontal a vertical y viceversa.

• Solución de un problema que provocaba que la pantalla del dispositivo se mostrara al revés después de sacar el iPhone 6 Plus del bolsillo.

• Resolución de un problema que en ocasiones impedía la rotación de las aplicaciones a la orientación correcta al cambiar de aplicación en multitarea.

Mejoras de accesibilidad

 

• Solución de un problema que provocaba que los gestos de VoiceOver no respondieran tras pulsar el botón Atrás en Safari.

• Solución de un problema que hacía que el foco de VoiceOver dejase de ser fiable en los borradores de Mail.

• Solución de un problema que impedía utilizar la función “Entrada braille en pantalla” para introducir texto en formularios de páginas web.

• Solución de un problema que hacía que al activar la navegación rápida en una pantalla braille se anunciara que la navegación rápida se había desactivado.

• Solución de un problema que impedía mover los iconos de las aplicaciones de la pantalla de inicio cuando VoiceOver estaba activado.

• Solución de un problema de “Leer pantalla” que ocasionaba que el habla no se iniciara de nuevo tras haber estado en pausa.

Mejoras para la empresa 

• Mejora de la fiabilidad de la instalación y la actualización de aplicaciones empresariales.

• Corrección de la zona horaria de los eventos de calendario creados en IBM Notes.

• Solución de un problema que convertía los iconos de los clips web en genéricos tras reiniciar el sistema.

• Mejora de la fiabilidad del sistema al guardar la contraseña de un proxy web.

• Posibilidad de editar un mensaje de ausencia de Exchange aparte para las respuestas automáticas externas.

• Mejora de la recuperación de cuentas Exchange después de un problema de conexión temporal.

• Mejora de la compatibilidad de las soluciones de proxy web y VPN.

• Posibilidad de utilizar teclados físicos para iniciar sesión en hojas web de Safari (por ejemplo, para acceder a una red Wi-Fi pública).

• Solución de un problema que provocaba el truncamiento de las reuniones de Exchange que contenían notas largas.

Otras mejoras y correcciones de errores 

• Teclado Emoji rediseñado con más de 300 caracteres nuevos.

• Optimización de la fototeca de iCloud, que ha dejado de ser beta, para ofrecer compatibilidad con la nueva aplicación Fotos de OS X 10.10.3.

• Mejora de la pronunciación de los nombres de las calles en la navegación paso a paso de Mapas.

• Compatibilidad con las pantallas braille Baum VarioUltra 20 y VarioUltra 40.

• Mejora de la visualización de los resultados de Spotlight con la opción “Reducir transparencia” activada.

• Nuevas opciones de formato Cursiva y Subrayado en el teclado horizontal del iPhone 6 Plus.

• Posibilidad de eliminar las direcciones de envío y facturación usadas con Apple Pay.

• Compatibilidad de Siri con más idiomas y países: inglés (India, Nueva Zelanda), danés (Dinamarca), holandés (Países Bajos), portugués (Brasil), ruso (Rusia), sueco (Suecia), tailandés (Tailandia), turco (Turquía).

• Más idiomas de dictado: árabe (Arabia Saudí, Emiratos Árabes Unidos) y hebreo (Israel).

• Mejora de la estabilidad de Teléfono, Mail, la conectividad Bluetooth, Fotos, las pestañas de Safari, Ajustes, Tiempo y las listas Genius en Música.

• Corrección de un problema que ocasionaba que en ciertos dispositivos no funcionara “Deslizar para desbloquear”.

• Corrección de un problema que en ocasiones impedía que se pudiese contestar a una llamada de teléfono deslizando el dedo en la pantalla bloqueada.

• Corrección de un problema que impedía abrir enlaces en los documentos PDF de Safari.

• Solución de un problema que hacía que al seleccionar la opción “Borrar historial y datos de sitios web” de los ajustes de Safari no se borraran todos los datos.

• Solución de un problema que impedía la corrección automática de la abreviatura “FYI” en inglés.

• Corrección de un problema que impedía la aparición de predicciones contextuales en la respuesta rápida.

• Solución de un problema que hacía que no se pudiera pasar al modo nocturno de Mapas desde el modo híbrido.

• Resolución de un problema que impedía iniciar llamadas FaceTime desde un navegador o una aplicación de terceros mediante URL de FaceTime.

• Solución de un problema que en ocasiones impedía la exportación correcta de fotos a carpetas de imágenes de cámara digital en Windows.

• Solución de un problema que a veces impedía completar una copia de seguridad del iPad con iTunes.

• Solución de un problema que causaba que las descargas de Podcast se estancaran al pasar de una red Wi-Fi a una red móvil.

• Solución de un problema que provocaba que a veces el tiempo restante del temporizador se mostrara como 00:00 en la pantalla bloqueada.

• Solución de un problema que en ocasiones impedía ajustar el volumen de las llamadas.

• Solución de un problema que hacía que a veces la barra de estado apareciera cuando no debía.