Blog del sitio: Tecnológico

Página: ()  1 ...  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28 ...135   ()
Imagen de Miguel Angel Cano Dakin
de Miguel Angel Cano Dakin - sábado, 8 de noviembre de 2014, 21:35
Todo el mundo

Fecha: 24/octubre/2014                  Hora: 11:15

Aplicación de pila

Evaluación de expresiones aritméticas

Prefijas: operación antes +ab

Infijas: operación en medio a+b

Posfijas: operación después ab+

Estas operaciones se utilizan para que se puedan resolver las ecuaciones aritméticas aplicando propiedad, es decir, que en el caso de que se quiera resolver primero una operación de prioridad la maquina transforma la expresión de infija a posfija o prefija para que le sea más fácil tener en cuenta las prioridades.

Para convertir de infija a posfija y prefijas:

Infijas:                 prefijas:                posfijas:                                                                

a+b*c^1/2                   +a/*b^12                     abc1^*2/+

 

Para convertir la operación a prefijas se pasa el operador del medio a antes de los caracteres que este operando, pero en el caso de que se quiera a pasar a posfija el operador en vez de ponerse antes se pone después.

Lo que aprendí fue la manera en las que se puede aplicar una pila y los procesos que puede realizar una máquina para resolver expresiones aritméticas.

 
Imagen de Miguel Angel Cano Dakin
de Miguel Angel Cano Dakin - sábado, 8 de noviembre de 2014, 21:03
Todo el mundo

Fecha: 20/octubre/2012                          

Aplicación de pila

Chequeo de paridad

Se pueden chequear expresiones por medio de pilas como lo son los paréntesis, para verificar que estas estén puestas correctamente en las expresiones.

La forma en que chequea que las paréntesis estén puestas correctamente, es que cuando al recorrer la expresión encuentra una paréntesis abierta la pone en la pila y cuando encuentra una paréntesis cerrada, quita de la pila la paréntesis abierta, si al finalizar el chequeo de la expresión queda algo en la pila, se lanzara error que falta cerrar las paréntesis

 

Si al chequear la expresión encuentra un paréntesis cerrada, entonces tratara de quitar de la pila pero como la pila no tiene ningún dato entonces lanzara el error de que falta un paréntesis abierto.

 

El código  de chequeo de paridad

public class ChequeoParidad {

 public static void main(String[] args) {

                 Regla <Character> p = new PilaVector<>();

                 String error = "Todo esta bien...";

                 String exp = JOptionPane.showInputDialog("Digite expresion : "); // ((a+b)*c  charAt(indice), length()=>8;

               for(int i = 0; i < exp.length(); i++){

                 if(exp.charAt(i)=='('){

                      p.poner(exp.charAt(i));

                 }else{

                  if(exp.charAt(i)==')'){

                       if(p.vacia()){

                       error = "Error, falta parentesis abierto..!";

                       break;

                        }else{

                                p.quitar();

                        }

                       }

                      }

                   }

                    if(!p.vacia()){

                                error = "Error, falta parentesis cerrado..!";

                    }

                    JOptionPane.showMessageDialog(null,error);

    }

}

 
Imagen de Roberto de Jesús Morrinson Romero
de Roberto de Jesús Morrinson Romero - sábado, 8 de noviembre de 2014, 17:00
Imagen de Roberto de Jesús Morrinson Romero
de Roberto de Jesús Morrinson Romero - sábado, 8 de noviembre de 2014, 16:56
Imagen de Miguel Angel Cano Dakin
de Miguel Angel Cano Dakin - sábado, 8 de noviembre de 2014, 16:04
Todo el mundo

Implementación cola

Estática: vector

 

Las variables que utilizamos para implementar una cola son:
max (indica la capacidad del vector)

Frente (indica el dato que está en el frente)

Fin (indica el valor que esta al final)

Todas las variables mencionadas anterior mente son de tipo int.

Los métodos que utiliza serian:
poner: pone al final

fin++;

c[fin] = dato;

quitar: quita al inicio

dato = c[frente];

frente++;

vacía: consulta se la cola está vacía

frente = =-1;

llena: consulta si la cola está llena

fin= =max-1;

 

Dinámica: cola

En este caso, ponemos por el último nodo y quitamos por el primer nodo.

 

Los métodos que utilizamos son:
poner: que pone un nodo al final de la cola

fin.setSig(new Nodo(dato,null));

fin= fin.getSig();

quitar: quita el primer nodo en la fila

dato = frente.getDato();

frente = frente.getSig();

vacia: preguntamos si la lista esta vacia

frente = = null;

En este caso no usamos el método lleno por qué ya que las listas son estructuras dinámicas pueden seguir creándose nodos.

 

Lo que aprendi es la forma de aplicar las colas en una lista enlazada, haciendo que esta lista cumpla la función de una cola

 
Imagen de Miguel Angel Cano Dakin
de Miguel Angel Cano Dakin - sábado, 8 de noviembre de 2014, 15:18
Todo el mundo

Pilas y Colas:

Son dinámicas o estáticas dependiendo de su implementación.

Son consideradas como reglas que se aplican en la estructura de datos lineales, como los vectores y las listas.

Pilas: Restringen las operaciones quitar o poner a un solo extremo de la estructura lineal. Se conoce como LIFO, es decir, el primer elemento almacenado es el primero en ser procesados.

Colas: Restringe las operaciones quitar o poner a extremos contrarios de la estructura lineal. Se conoce como FIFO, es decir, primer elemento almacenado primero en ser procesado.

Estructura               Unidad                            Aplicación

Pila                Cuando se retrocede en un proceso      S.O llamado: sub programas

                   Para terminar operaciones pendientes    Compilador: Evaluación de                                    

                                                     expresión aritméticas

 

Cola                Cuando los recursos no son            Cola de impresión

                    Suficientes para atender un gran        Cola de procesos

                    Numero de tareas.

Implementación clase Pila vector

 

Max: capacidad de almacenamiento

Top: Índice en donde se encuentra el último elemento almacenado.

Hay que recordar que las variables anteriores deben ser de tipo int.

Las funciones que debe realizar la pila son:

Poner: 

tope++;

v[tope]=dato;

vacio:

tope==-1;

quitar:
dato=v[tope];

tope--;

lleno:

tope==max-1;

cima:

dato=v[tope];

Para su implementación con listas enlazadas

En este caso por el mismo lado que se inserta el nodo es por donde se quita.

 

Las funciones que debe realizar son:
poner:

Tope=new Nodo(dato,tope);

quitar:

dato=tope.getDato();

tope=tope.getSig();

cima:

dato=tope.getDato();

vacia:

tope==null;

Lo que aprendi fue la forma mas eficas de manejar las pilas y colas ademas de su significado

 
Imagen de Luis Enrique Ayin Arias
de Luis Enrique Ayin Arias - sábado, 8 de noviembre de 2014, 14:21
Todo el mundo

31-10-2014

APLICACIÓN DE PILAS

Evaluaciones de expresiones aritméticas: las pilas permiten evaluar las expresiones a partir de notaciones que no tienen paréntesis e incluyen las prioridades de operacione.

 

Notaciones

Prefija: operador antes +ab

Infija: operador en medio a+b

Posfija: operador después ab+

ejemplo

convertir de infija(a+b*c^1/2) a prefija y posfija 

prefija

a+b*c^1/2

a+b*^c1/2

a+*b^c1/2

a+/*b^c12

+a/*b^c12

posfija

a+b*c^1/2

a+b*c1^/2

a+bc1^*/2

a+bc1^*2/

abc1^*2/+

aqui tenemos un ejemplo de como convertir en las diferentes notaciones 

 

 
Imagen de Luis Enrique Ayin Arias
de Luis Enrique Ayin Arias - sábado, 8 de noviembre de 2014, 14:06
Todo el mundo

20-10-2014

1. chequeo de paridad

2. evaluacion de epresiones aritmeticas

 

import javax.swing.JOptionPane;

public class ChequeoParidad {

 

    public static void main(String[] args) {

                               Regla <Character> p = new PilaVector<>();

                               String error = "Todo esta bien...";

                    String exp = JOptionPane.showInputDialog("Digite expresion : "); // ((a+b)*c   charAt(indice), length()=>8;

                    for(int i = 0; i < exp.length(); i++){

                                if(exp.charAt(i)=='('){

                                               p.poner(exp.charAt(i));

                                }else{

                                               if(exp.charAt(i)==')'){

                                                               if(p.vacia()){

                                                                               error = "Error, falta parentesis abierto..!";

                                                                               break;

                                                               }else{

                                                                               p.quitar();

                                                               }

                                               }

                                }

                    }

                    if(!p.vacia()){

                                error = "Error, falta parentesis cerrado..!";

                    }

                    JOptionPane.showMessageDialog(null,error);

    }

}

 

con este codigo mas el laboratorio hecho anteriormente utilizando las mismas clases y la interface hacemos el chequeo de algunas expresiones 

((a+b)*c

)(a+b)*c(

 
Imagen de Luis Enrique Ayin Arias
de Luis Enrique Ayin Arias - sábado, 8 de noviembre de 2014, 13:55
Todo el mundo

17-10-2014

Int {max}

Int {frente}

Int {fin}

                                                                                                               

PONER: {fin++;

                C[fin] = dato;}

 

QUITAR: {dato = C[frente];

                  Frente ++;}

 

 

VACIA:{frente == -1;}

LLENA: {FIN == MAX -1;}

 

DINAMICA(Nodos)

 

 

PONER: {fin.setSig(new Nodo(dato,null));

                Fin = fin.getSig();}

 

QUITAR: {dato = frente.getDato();

                  Frente = frente.getSig();}

 

VACIA:{frente == null;}

________________________________________________________________________

public class PilaVector <T> implements Regla <T> {

    private T v[];

    private int tope;

    private int max;

    public PilaVector() {

                               max = 100;

                               tope = -1;

                               v = (T[]) new Object[max];

    }

    public PilaVector(int max) {

                               this.max = max;

                               tope = -1;

                               v = (T[]) new Object[max];

    }

    public boolean vacia(){return tope == -1;}

    public boolean llena(){return tope == max-1;}

    public void poner(T dato){

                if(!llena()){

                               tope++;

                               v[tope] = dato;

                }else{

                               System.out.println("Pila llena..!");

                }

    }

    public T quitar(){

                T dato = null;

                if(!vacia()){

                               dato = v[tope];

                               tope--;

                }else{

                               System.out.println("Pila vacia..!");

                }

                return dato;

    }

    public T cima(){

                T dato = null;

                if(!vacia()){

                               dato = v[tope];

                }else{

                               System.out.println("Pila vacia..!");

                }

                return dato;

    }

}

 _________________________________________________________________________________

public class ColaNodo<T> implements Regla<T> {

                private Nodo <T> frente;

                private Nodo fin;

    public ColaNodo() {

                frente = fin = null;

    }

    public boolean vacia(){return frente == null;}

    public boolean llena(){return new Nodo(new Object(),null)==null;}

    public void poner(T dato){

                if(!llena()){

                               if(vacia()){

                                               frente = fin = new Nodo(dato, null);

                               }else{

                                               fin.setSig(new Nodo(dato,null));

                                               fin = fin.getSig();

                               }

                }else{

                               System.out.println("Memoria agotada..!");

                }

    }

    public T quitar(){

                T dato = null;

                if(!vacia()){

                               dato = frente.getDato();

                               frente = frente.getSig();

                }else{

                               System.out.println("Cola vacia..!");

                }

                return dato;

    }

    public T cima(){

                T dato = null;

                if(!vacia()){

                               dato = frente.getDato();

                }else{

                               System.out.println("Cola vacia..!");

                }

                return dato;

    }

}

 __________________________________________________________________________

public class Nodo <T> {

                private T dato;

                private Nodo sig;

    public Nodo(T dato, Nodo sig) {

                this.dato = dato;

                this.sig= sig;

    }

    public T getDato(){

                return dato;

    }

    public Nodo getSig(){

                return sig;

    }

    public void setSig(Nodo sig){

                this.sig = sig;

    }

}

______________________________________________________________

public interface Regla <T>{
 public boolean vacia();
 public boolean llena();
 public void poner(T dato);
 public T quitar();
 public T cima();
}

___________________________________________________________

public class PruebaRegla {

 

    public static void main(String[] args) {

 

        Regla p,c;

        p = new PilaVector(3);

        c = new ColaNodo();

        p.poner("JUan");

        p.poner("Jose");

        p.poner("Puello");

        p.poner("Fuentes");

        mostrar(p);

        c.poner("JUan");

        c.poner("Jose");

        c.poner("Puello");

        c.poner("Fuentes");

        mostrar(c);

    }

 

    public static void mostrar(Regla x){

                while(!x.vacia()){

                               System.out.println(x.quitar());

                }

                System.out.println();

    }

}

 

este es un laboratorio donde se implemento una pila y una cola con sus respectivos metodos y clases

se crea una clase interface, una clase colaNodo, una clase PilaVector estas dos implementan de la interface Regla creamos una clase Nodo y la clase Main o principal

[ Modificado: sábado, 8 de noviembre de 2014, 14:10 ]
 
Imagen de Luis Enrique Ayin Arias
de Luis Enrique Ayin Arias - sábado, 8 de noviembre de 2014, 13:30
Todo el mundo

10-10-2014

PILAS Y COLAS

son reglas que se aplican a estructuras de datos lineales (vectores y listas enlazadas).

Pilas: es  una regla que restringe las operaciones (quitar y poner) a un solo extremo de la estructura lineal. LIFO: ultimo elemento almacenado, primero en ser procesado.

 

Colas: es una regla que restringe las operaciones (quitar y poner) a extremos contrarios de la estructura lineal. FIFO: primer elemento almacenado, primero en ser procesado.

REGLA DE ESTRUCTURA PILA

UTILIDAD: cuando se retrocede en un proceso para terminar operaciones pendientes.

APLICACIONES: S.O.: llamado subprograma, COMPILADOR: evaluación en expresiones aritméticas.

REGLA ESTRUCTURA COLA

UTILIDAD: cuando los recursos no son suficientes para atender un gran numero de tareas.

APLICACIONES: cola de impresión, cola de procesos.

 

Int { max:capacidad de almacenamiento

Int { tope: índice donde se encuentra el ultimo elemento almacenado

 

PONER: {tope ++;

                 v[tope] = dato; }

 

QUITAR: { dato = v[tope];

                   Tope—1;}

 

CIMA: {dato = v[tope];}

VACIA: {tope == -1;}

LLENA:{tope == max-1;}

 

 

 

DINAMICA (listas enlazadas)

 

PONER: {tope = new Nodo(dato,tope);}

QUITAR: { dato = tope.getDato();

                   Tope = tope.getSig();}

 

CIMA: {dato = tope.getDato;}

 

VACIA: {tope == null;}

 

 

public class PilaVector <T> {

    private T v[];

    private int tope;

    private int max;

    public PilaVector() {

                               max = 100;

                               tope = -1;

                               v = (T[]) new Object[max];

    }

    public PilaVector(int max) {

                               this.max = max;

                               tope = -1;

                               v = (T[]) new Object[max];

    }

    public boolean vacia(){return tope == -1;}

    public boolean llena(){return tope == max-1;}

    public void poner(T dato){

                if(!llena()){

                               tope++;

                               v[tope] = dato;

                }else{

                               System.out.println("Pila llena..!");

                }

    }

    public T quitar(){

                T dato = null;

                if(!vacia()){

                               dato = v[tope];

                               tope--;

                }else{

                               System.out.println("Pila vacia..!");

                }

                return dato;

    }

    public T cima(){

                T dato = null;

                if(!vacia()){

                               dato = v[tope];

                }else{

                               System.out.println("Pila vacia..!");

                }

                return dato;

    }

}

en esta clase vimos como se implementa y se comporta una pila en un vector con todos sus metodos 

[ Modificado: sábado, 8 de noviembre de 2014, 14:02 ]
 
Página: ()  1 ...  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28 ...135   ()