Aplicacion de Pila. Expresiones Aritmeticas

Aplicación de Pila. Expresiones Aritméticas

Una de las aplicaciones de pila son las expresiones aritméticas  estas facilitan la evaluación quitando paréntesis y ordenando el orden de operación según  prioridad al hacer la evaluación. Existen expresiones Aritméticas como:

inflija: son las expresiones que tienen el operador en el medio.

prefija: son las que tienen el operadores antes.

posfija: son las que tienen el operadores después.

Para realizar la aplicación de las expresiones aritméticas en pila es necesario pasar las expresiones inflijas a  prefijas y posfija. 

para realizarlo se guarda en una pila los operando  al encontrar un operador se sacan de la pila dos operando se realiza la operación y se guarda en la pila el resultado como se muestra en la figura numero 8.

Figura numero 8

Ejercicio de Expresiones Aritméticas conversión de inflijas a prefijas y posfijas. 

1. a+b*c^1/2 

Para convertir cualquier expresión aritmética inflija a prefija se necesita conocer sobre cual operador tiene mas prioridad cuales tienen iguales y cual tiene menor prioridad, al momento de convertir si nos encontramos con dos operadores que tienen iguales prioridades se realiza primero el operador que este mas a la izquierda, conociendo esto pasaremos a la conversión.

prefijas 

a+b*^c1/2   se paso el operador de el exponente ya que tiene mas prioridad de todos los operadores  y como la vamos a convertir a prefija se pasa el operador adelante de c.

a+*b^c1/2

a+/*b^c12

+a/*b^c12 resultado.

  posfijas

a+b*c^1/2  

a+b*c1^/2

a+bc1^*/2  

abc1^*2/+ resultado.

Ejercicios lógica de pilas

Función o métodos para:

1. Eliminar el primer elemento.

2.  Intercambiar los elementos de los extremos.

3. Eliminar elementos repetidos en forma consecutiva.

Métodos:

1.  

public void eliminarPrimero(Pila p){

T d = null;
d=((T) p.quitar());
while(!p.vacia()){
System.out.println(p.quitar());
}
}

2.  

public static void intercambiarElementosExtremos(Pila p){
Pila q,r;
q=new Pila <> ();
q.poner(p.quitar());
r= new Pila();
while(!p.vacia()){
r.poner(p.quitar());
}
p.poner(q.quitar());
q.poner(r.quitar());
while(!r.vacia()){
p.poner(r.quitar());
}
p.poner(q.quitar());

}

3. 

public static void eliminarRepetidoConsecutivo(Pila p){
Pila q = new Pila ();
q.poner(p.quitar());
while(!p.vacia()){
if(!p.cima().equals(q.cima())){
q.poner(p.quitar());
} else {
p.quitar();
}
}
while (!q.vacia()){
p.poner(q.quitar());
}
}

Apreciaciones importantes y reflexión:

En el primer metodo Se recibe la pila en la cual vamos a eliminar el primer elemento, se define una variable que recibira el dato que se quiere eliminar, luego se quita de la pila  cual elemento es el primero. Después de haber hecho esto  se imprimen los demás datos con una estructura repetitiva while.

En el segundo método  tambien se recibe una pila en la cual se cambiaran los elementos del extremo, se definen dos pilas que serviran de auxiliares llamadas q y r,  se quita el primer dato y se guarda en la pila q, luego se guradan los datos que quedan de la pila original a la otra pila auxiliar r, se guarda el dato que se encuentra en la pila q a la pila original p, luego es guardado el primer valor que se encuentra en la pila r a la pila q, se guardan los demas daos en la pila original, y es guardado también el dato que se encuentra en la pila r el cual anteriormente era el ultimo ahora es el primero.  

En el tercer método se tuvo en cuenta declarar una pila que sirve de auxiliar y tambien se recibe una pila, se saca el primer dato que trae la pila que recibe el metodo,  mediante un while se van sacando los demas datos, se va preguntando si el elemento que se saco es diferente al que esta en  la cima del original en caso de que esto se cumpla se pone en la pila q lo que va sacando de p, en caso de que no se cumpla se quita de la pila p y ese dato eliminado  automáticamente, luego se vuelve a mandar los datos en la forma que estaban a la pila original.