Pilas

Estructuras de Datos

Estructuras de Datos

Lineales

No lineales

Almacenamiento Contiguo

Almacenamiento No

Contiguo

árboles

Pilas,colas,listas

Memoria

Datos

Programas

Stack (Pila)

Heap (montón) Buffer

VideoMemoria RAM

Memoria

V

0 1 2 3 4

2 2 2 2 2

D1 d2 D3 d4 D5 d6 D7 d8 D9 d10

Bytes por elemenrto

Dirección de memoria

v=900; es un error. Debe especificarse un elemento del arreglo

V[3]=900; en el cuarto elemento del arreglo se asigna el 900.

¿Cómo realiza la asignación en la localidad de memoria correcta?

Dirección inicio del arreglo + Sub*Byte

Para sub=3,

1 2 3 4 5 6 7 8 9 10

DI + 3 * 2 = 1 + 3 * 2 = 1 + 6 = 7

Observe que el tercer elemento del arreglo inicia en la dirección 7.

Memoria

La definición anterior se dice que es un tipo estructurado (ya que puede representar a un conjunto de datos), pero cada uno de los elementos solo puede representar a un solo dato (tipo simple).

¿Qué hacer si necesitamos que los elementos del arreglo representen datos estructurados?

Clave

Edad

Estatura

Clave

Edad

Estatura

Clave

Edad

Estatura

Clave

Edad

Estatura

•Definir una clase que contenga los atributos que deseamosclass dato

{ public int clave;

public int edad;

public float estatura;

}

Memoria

• Definir el arreglo

dato [ ] v = new dato[5]

V Dirección Memoria

null null null null null

• Crear a cada elemento un objeto donde estarán los datos

for( int i=0 ; i<5 ; i++)

v[i]=new dato();

Dirección Memoria

ClaveEdad

Estatura

ClaveEdad

Estatura

ClaveEdad

Estatura

ClaveEdad

Estatura ClaveEdad

Estatura

for( i=0 ; i<5 ; i++)

{ v[i].clave=i+1;

v[i].edad=i*10;

v[i].estatura=i+0.5;

}

Memoria

V Dirección Memoria

Clave=1Edad=0

Estatura=0.5

Clave=4Edad=30

Estatura=3.5

Clave=3Edad=20

Estatura=2.5

Clave=5Edad=40

Estatura=4.5 Clave=2Edad=10

Estatura=1.5

Operaciones Básicas en Estructuras Lineales

1. Recorrido: Procesa c/elemento de la estructura.

2. Búsqueda: Recupera la posición de un elemento específico.

3. Inserción: Adiciona un nuevo elemento a la estructura.

4. Borrado: Elimina un elemento de la estructura.

5. Ordenación: Ordena los elementos de la estructura de acuerdo a los valores que contiene.

6. Mezcla: Combina 2 estructuras en una sola.

Aritmética de notación

Existen diversas formas para representar nuestros algoritmos y estas representaciones pueden ayudarnos en la comprensión de los mismos; así como poderlos trasladar a algún lenguaje de programación.

Notaciones matemáticasFunción factorial: Es el producto de los n

números enteros positivos que van desde 1 hasta n

Ejemplo:

n! 2!= 1.2=2 3!= 1.2.3=6 4!=1.2.3.4=24

NOTACIONES:

NOTACIONES:

Notaciones matemáticas Simbolo de la suma (sumatorio)

El simbolo sumatorio es ∑

Ejemplo:

Sea la secuencia a1, a2, a3, a4,……..an

Las sumas

a1+a2+a3+a4+ ……. +an = ∑ an

J=1

NOTACION INFIJA:Los operadores aparecen en medio de los operandos. A + B, A – 1, E/F, A * C , A ^ B , A + B + C

NOTACION PREFIJA:El operador aparece antes de los operandos. + AB, - A1, /EF, *AC, ^AB, ++ABC

NOTACION POSTFIJA:El operador aparece al final de los operandos. AB+, A1-, EF/, AC*, AB^, AB+C+

NOTACIONES:NOTACIONES:

PILAS

Estructura de datos lineal donde los elementos pueden ser añadidos o removidos solo por un extremo.

Esta estructura tiene una filosofia LIFO (last-in, first-out), ultimo en entrar, primero en salir

Ejemplos:•Pila de platos.•Pila de monedas.•Pila de discos.

OPERACIONES BASICAS CON PILAS

-PUSH (insertar).- Agrega un elementos a la pila en el extremo llamado tope.

-POP (remover).- Remueve el elemento de la pila que se encuentra en el extremo llamado tope.

-VACIA.- Indica si la pila contiene o no contiene elementos.

-LLENA.- Indica si es posible o no agregar nuevos elementos a la pila.

REPRESENTACIÓN DE PILAS:Usando arreglos: Define un arreglo de una dimensión (vector) donde se almacenan los

elementos.

0 1 2 3 4 5

TOPE: Apunta hacia el elemento que se encuentra en el extremo de la pila. (inicialmente es null).

Ejemplo:

Inicio:

Insertar

A:

Tope

Null

Insertar

B:

Insertar

C:

Eliminar

Tope

A A

B

Tope

A

B

Tope

C

A

B

Topetope tope tope tope tope

pila

xxx yyy zzz

1 2 3 4 5 6 7 8

Cima maxpila3 8

Si queremos insertar un dato en la pila METER(pila, WWW), que pasos tenemos que seguir?

Si queremos sacar un dato en la pila SACAR(pila, ITEM), que pasos tenemos que seguir?

Realizar el siguiente EjercicioDibuje los distintos estados de una estructura tipo pila si se llevan

a cabo las siguientes operaciones. Muestre como va quedando la pila y el puntero al tope de la misma. Considere que la pila esta inicialmente vacia (Tope=0):

a) Insertar(Pila,X);b) Insertar(Pila,X);c) Eliminar(Pila,X);d) Insertar(Pila,X);e) Eliminar(Pila,X);f) Eliminar(Pila,X);g) Eliminar(Pila,X);h) Insertar(Pila,X);i) Insertar(Pila,X);j) Eliminar(Pila,X);k) Insertar(Pila,X);

Responda las siguientes preguntas:Con cuantos elementos quedo la pila?Hubo algun caso de error? Explique

Métodos básicos para implementar la pila son: Pila_llena()Devuelve verdadero si la pila esta llena Pila_vacia();Devuelve verdadero si la pila esta vacia Insertar_push (int elem);Agrega el elemento a la pila Retirar_pop();Elimina el elemento que esta en la cima de la pila

Interface para una pila de enteros:

interface IPila {

public boolean pila_llena();

public boolean pila_vacia();

public void insertar_push (int elem);

public int retirar_pop();

}

Algoritmo para la operación para verificar si la pila esta vacia

Pila_vacia()

1. Si tope igual a -1

Entonces regresar band<- verdadero

Si no regresar band <- falso

2. {fin del condicional del paso 1}

Hacer el algoritmo para verificar si la Hacer el algoritmo para verificar si la pila esta llenapila esta llena

Ejercicio

Hacer el método para el algoritmo pila_vacia

Realizar el método para pila_llena

Algoritmo para insertar un elemento de la pila

insertar_push (int elem); Verificar si la si la esta llenaSi la pila esta llena; enviar mensaje

de que esta llenaSi no

• se prepara a insertar, incrementando el tope de la pila

• se inserta el elemento en la pila

{fin del condicional}Hacer el algoritmo para insertar un Hacer el algoritmo para insertar un elemento a la pilaelemento a la pila

public void push (int elem) { if (this.llena())

ERROR else{ tope ++; pila [ tope ] = elem; } }

Algoritmo para retirar un elemento de la pila

Retirar_pop (int elem); Verificar si la pila esta vaciaSi esta vacia; enviar mensaje de que

esta llenaSi no

se respalda el elemento a eliminarse decrementa el tope de la pila

se regresa el valor eliminado de la pila

{fin del condicional}

Hacer el algoritmo para retirar un Hacer el algoritmo para retirar un elemento a la pilaelemento a la pila

public int pop() { if (this.vacia())

ERROR else{ int x = pila[tope]; tope --; return x; }}

Implementación usando un arreglo:class Pila {

int tope = -1;private int [] pila = new int [10];final int max = 9;

public boolean llena(){return ( tope == max);

}public void push (int elem){ if (this.llena())

ERROR else{ tope ++;

pila [ tope ] = elem;}

}

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

}

public int pop(){if (this.vacia())

ERRORelse{

int x = pila[tope];tope --;return x;

}}

}

Implementación usando un Vector

public class Stack { private Vector items; public Stack() { items = new Vector(10); } public Object push(Object item){ items.addElement(item); return item; } public synchronized Object pop(){ int len = items.size(); Object obj = null; if (len == 0) throw new EmptryStackException(); obj = items.elementAt(len-1); items.removeElementAt(len –1); return obj; } public boolean isEmpty() { if (items.size == 0) return true; else return false; }}

Ejemplo de la implementación de la clase pila

class Pilas_Mias{private Object pila[];private int tope=-1;private Object dato;private int max=0; Pilas_Mias(int maximo){ max=maximo; pila=new Object[max]; }

public void borrarpila() { tope=-1; }

private boolean Pila_llena() { boolean res=false; if(tope==(max-1)) {

res= true; } else {

res= false; }

return res;}

private boolean Pila_vacia() { boolean res=false; if(tope==-1) res=true;

return res; }

public boolean Insertar_pila(Object dato){ boolean res=false; if(!Pila_llena()) { tope++; pila[tope]=dato; res=true; } return res;}

public Object retirar_pila() { Object res; if(!Pila_vacia()) {

res=pila[tope];tope--;

} else {

System.out.println("pila vacia "); res="no se pudo retirar";

} return res; }

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

}

pila1.Insertar_pila("hola");pila1.Insertar_pila(333);pila1.Insertar_pila(“pepe");pila1.Insertar_pila(444);

pila1.Mostrar();

pila1.Insertar_pila(“ana”);pila1.retirar_pila();

pila1.Mostrar(); //pila1.borrarpila();

retirar_pila();pila1.Mostrar();

pila1.retirar_pila();pila1.Insertar_pila(“nuevo");

pila1.Mostrar();

T -1 T 0

hola

hola

333

T 1

hola

333

T 2

pepe

hola

333

T 3

pepe

444

T 4

hola

333pep

e

444ana

T 3

hola

333pep

e

444

hola

333

T 2

pepe

hola

333

T 1

hola

333

T 2

nuevo

Max=5

La pila puede representarse por medio de:

Arreglos (memoria estática)

Una vez definido el tamaño del arreglo no se cambia su tamaño

Listas enlazadas (memoria dinámica)

Se almacenan los elementos como nodos y el tamaño se ajusta exactamente a los elementos de la pila

c

b

a

tope

pila

Max = 5

abc

pilad

tope

Invertir una cadena de caracteres utilizando una pila

• Tenemos de entrada una cadena de caracteres => ana

• Si la pila no esta llena, Almacenar carácter por carácter en la pila

a

l

i

p

• Si la pila no esta vacía, retirar carácter por carácter de la pila para que quede invertida

Cadena invertida => alip

Ejemplo invertir cadenaimport java.io.*;import java.util.*;

public class Invertir_cadena{ public static void main(String args[]) throws IOException { String cadena; BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));

System.out.print("Teclea una cadena ==> "); cadena=stdin.readLine(); System.out.println();

Pilas_Mias pila1=new Pilas_Mias(5); boolean Resins; System.out.println("--Original--"); for(int i=0; i<cadena.length();i++) { Resins=pila1.Insertar_pila(new String (cadena.substring(i,i+1))); if(!Resins)

{System.out.println("pila llena no se inserto el elemento "+cadena.substring(i,i+1));} }

System.out.println(); pila1.Mostrar(); System.out.println("--Invertida--"); String Res=pila1.retirar_pila().toString();

while(Res.compareTo("no se pudo retirar") != 0) //mientras este retirando { System.out.println(Res); Res=pila1.retirar_pila().toString(); }

System.out.println(); }}

Ejercicio

Modificar el programa anterior para dada una cadena, verificar si esa cadena en un palíndromo (invertido es igual).

Ejemplo de palindromo

original ANA

Invertida ANA

ANA es un palíndromo

PALINDROMOpublic class palindromo{ public static void main(String args[]) throws IOException { String cadena; String pali=""; BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));

System.out.print("Teclea una cadena ==> "); cadena=stdin.readLine(); System.out.println();

Pilas_Mias pila1=new Pilas_Mias (cadena.length());

boolean Resins; System.out.println("--Original--");

for(int i=0; i<cadena.length();i++) { Resins=pila1.Insertar_pila(new String (cadena.substring(i,i+1))); if(!Resins) { System.out.println("pila llena no se inserto el elemento "+cadena.substring(i,i+1)); } }

PALINDROMOSystem.out.println(); pila1.MostrarOri(); String Res=pila1.retirar_pila().toString(); pali=pali+Res;

while(Res.compareTo("no se pudo retirar")!=0) { Res=pila1.retirar_pila().toString(); if(Res.compareTo("no se pudo retirar")!=0) {

pali=pali+Res; } }

System.out.println(); if (cadena.compareTo(pali)==0) {System.out.println("la cadena SI es un palindromo => "+pali + " = "+ cadena);} else {System.out.println("la cadena NO es un palindromo => "+pali + " = "+ cadena);} }}

De acuerdo al siguiente algoritmo, realizar el programa en javaAlgoritmo palindromo2Var inicio Leer palabra Desde i:=1 hasta largo (palabra) insertar_pila(palabra[i]) Fin_Desde Desde i:=1 hasta largo (palabra) Si palabra[i]!=ret_pila(Dato) salir Fin_Si Fin_Desde Si pila_vacia entonces imprime (‘si es palindromo’) De lo contrario imprime(‘no es palindromo’) Fin _Si

public class palindromo2{ public static void main(String args[]) throws IOException {

String palabra;BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));

System.out.print("Teclea una palabra ==> ");palabra=stdin.readLine();System.out.println();

Pilas_Mias pila1=new Pilas_Mias(palabra.length());

for(int i=0; i<palabra.length();i++){ pila1.Insertar_pila(new String (palabra.substring(i,i+1)));} for(int i=0; i<palabra.length();i++){ if(palabra.substring(i,i+1).compareTo(pila1.retirar_pila().toString())!=0)

break; }

if(pila1.retirar_pila().toString().compareTo("no se pudo retirar")==0) System.out.println("La palabra SI es palindromo"); else System.out.println("La palabra NO es palindromo");

}}

Aplicaciones de PilasEvaluación de paréntesis en el analisis sintáctico.Ejemplo:(A+B))(A+B)((A+B)([A+B])(([[A+B]]))

Condicion Para que los parentesis esten correctos es:1. Que la pila este vacía2. Que no quede ningún paréntesis que cierre pendiente

Ejemplo con las operaciones anteriores

Evaluar los parentesisExpresion = ([(A+B)*(C+D)])

T 0

(

T 1

([

T 2

([(

T 1

([

T 2

([(

T 1

([

T 0

(

T -1

( [ ( ) (

) ] )

public class Parentesis_Correctos{ public static void main(String args[]) throws IOException {

BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));

Pilas_Mias pila_parentesis=new Pilas_Mias(50);

String Expresion="";String Caracter="";boolean SI_ES=true;String Ret="";

System.out.print("Escribe la expresion a evaluar ==> ");Expresion=stdin.readLine();System.out.println();

for(int i=0; i<Expresion.length();i++){ Caracter=Expresion.substring(i,i+1); if(Caracter.compareTo("(")==0 || Caracter.compareTo("[")==0) { pila_parentesis.Insertar_pila(new String (Caracter)); System.out.println("Insertar => " + Caracter); } else

if(Caracter.compareTo(")")==0 || Caracter.compareTo("]")==0) { Ret=pila_parentesis.retirar_pila().toString(); System.out.println("Retirar => " + Ret); if (Ret.compareTo("no se pudo retirar")==0)

{ SI_ES=false; }

}

} Ret=pila_parentesis.retirar_pila().toString(); System.out.println("Pila " + Ret);

// SI_ES=TRUE Y LA PILA ESTA VACIA if(SI_ES && Ret.compareTo("no se pudo retirar")==0) { System.out.println("Parentesis correctos"); } else { System.out.println("Parentesis incorrectos"); } }}

Resultados Correcto e incorrecto

TAREA

Modificar el programa Parentesis_Correctos.java para verificar si los paréntesis están correctos

EXPRESIONES ARITMETICAS:

Una expresión aritmética contiene constantes, variables y operaciones con distintos niveles de precedencia.

Una expresión aritmética esta formada por operandos y operadores.

R=X*Y – (A*B)

Las expresiones aritméticas pueden ser representadas en 3 notaciones distintas.

Aplicaciones de Pilas

() paréntesis

^ potencia

* / multiplicación, división

+,- suma, resta

PRESEDENCIA OPERADORES :

Nivel mayor prioridad

Nivel menor prioridad

NOTACION INFIJA: es la forma habitual de escribir operacionesaritméticas es la de situar el operador entre sus dosoperandos. El operador se evalúa dentro de losOperandos.

Los operadores aparecen en medio de los operandos. A + B, A – 1, E/F, A * C , A + B + C

NOTACION PREFIJA: (polaca)El operador aparece antes de los operandos. + AB, - A1, /EF, *AC, ++ABC, +- ABC


NOTACION POSTFIJA: (polaca)El operador aparece al final de los operandos. AB+, A1-, EF/, AC*, AB^, AB+C+, AB+C-


Reglas para convertir de infija a posfija o prefija

La ventaja de utilizar expresiones en notación polaca (posfija o prefija) radica en que no son necesarios los paréntesis para indicar el orden de operación, ya que esto queda establecido por la ubicación de los operadores de más alta prioridad se ejecuta primero.

Si hubiera en una expresión 2 o mas operadores de igual precedencia, se procesa de izquierda a derecha.

Las expresiones con paréntesis se ejecutan primero

De infija a prefijaA*B/(A+C) (infija) -> A*B/+AC -> *AB/+AC -> /*AB+AC (prefija)

A*B/A+C -> *AB/A+C -> /*ABA+C -> +/*ABAC

(A-B)ˆC+D -> -ABˆC+D -> ˆ-ABC+D -> +ˆ-ABCD

A*B/(A+C) (infija) -> A*B/AC+ -> AB*/AC+ -> AB*AC+/ (postfija)

A*B/A+C -> AB*/A+C -> AB*A/+C -> AB*A/C+

(A-B)ˆC+D -> AB-ˆC+D -> AB-Cˆ+D -> AB-CˆD+

De infija a postfija

Conversión a posfijo La transformación inicia utilizando una pila en la que se almacenan

los operadores y los paréntesis

La expresión se va leyendo carácter a carácter, los operandos pasan directamente a formar parte de la expresión en posfijo

Los operadores se meten a la pila siempre que esta este vacía, o bien siempre que tengan mayor prioridad que el operador cima de la pila

Si la prioridad es menor o igual se saca el elemento cima de la pila y se vuelve a hacer la comparación con el nuevo elemento cima

Los paréntesis izquierdos siempre se meten en la pila con la mínima prioridad. Cuando se lee un paréntesis derecho, hay que sacar todos los operadores de la pila pasando a formar parte de la expresión postfija, hasta llegar a un paréntesis izquierdo, el cual se elimina ya que los paréntesis no forman parte de la expresión

El algoritmo termina cuando no hay mas items de la expresión y la pila esta vacía

Transformación de expresiones infijas en expresiones postfijas Expresión en infija: A+(B*C-(D/E^F)*G)*H

Simbolo PILA Expresion PA+(B*C-(D/E^F)*G)*H

++ (+ (+ ( *+ ( *+ ( -+ ( - (+ ( - (+ ( - ( /+ ( - ( /+ ( - ( / ^+ ( - ( / ^+ ( -+ ( - *+ ( - *++ *+ *

AAAA BA BA B CA B C *A B C *A B C * DA B C * DA B C * D EA B C * D EA B C * D E FA B C * D E F ^ /A B C * D E F ^ /A B C * D E F ^ / GA B C * D E F ^ / G * -A B C * D E F ^ / G * -A B C * D E F ^ / G * - HA B C * D E F ^ / G * - H * +

Ejemplo Expresión A* (B+C-(D/E ˆF)-G)-H

A Carácter A a la expresión; carácter * a la pila

AB Carácter ( a la pila; carácter B a la expresión

ABC Carácter + a la pila; carácter C a la expresión

El nuevo carácter leido es - , que tiene la misma prioridad que el elemento cima de la pila + ; en consecuencia el estado de la pila es :

Y la expresion es:

ABC+

ABC+D Carácter ( a la pila; carácter D a la expresión

ABC+DE Carácter / a la pila; carácter E a la expresión

*

(+

*

(-

*

(-(/

ABC+DEF Carácter ˆ a la pila; carácter F a la expresion

Carácter ) provoca vaciar la pila hasta un (

La pila en este momento contiene

El nuevo estado de la pila es

Y la expresión:

ABC+DEF ˆ /

ABC+DEF ˆ /- Carácter – a la pila y se extrae a su vez –ABC+DEF ˆ /-G Carácter G a la expresion; carácter ) son extraidos de la pila los operadores hasta un ( la pila queda:

ABC+DEF ˆ /-G-* Carácter -, se saca de la pila * y se mete –ABC+DEF ˆ /-G-*H Carácter H se lleva a la expresion

Fin de entrada, se vacia la pila: ABC+DEF ˆ /-G-*H -

*

(-(/ˆ

*

(-

Expresión A* (B+C-(D/E ˆF)-G)-H

*

-

REGLAS PARA CONVERTIR EXPRESION INFIJA A POSTFIJASe crea un string resultado donde se almacena la expresion postfija.

1.- Los operandos se agregan directamente al resultado

2.- Un paréntesis izquierdo se mete a la pila y tiene prioridad o precedencia cero (0).

3.- Un paréntesis derecho saca los elementos de la pila y los agraga al resultado hasta sacar un paréntesis izquierdo.

4.- Los operadores se insertan en la pila si:

a) La pila esta vacía.

b) El operador en el tope de la pila tiene menor precedencia.

c) Si el operador en el tope tiene mayor precedencia se saca y agrega al resultado (repetir esta operacion hasta encontrar un operador con menor precedencia o la pila quede vacia).

5.- Cuando se termina de procesar la cadena que contiene la expresión infija se vacía la pila pasando los elementos al resultado.

Resultados de infijo a postfijo

a*(b+c-(a+b/c)-a)-b

(a+b)*c-b

Conversión de infija a prefija

La conversión se hace de la misma forma que de infija a postfija, con las siguientes diferencias:

1. Se lee la expresión a evaluar de derecha a izquierda

2. El paréntesis que cierra entra a la pila y lo saca el paréntesis que abre

3. Se invierte la solución

Ejemplos(x+z)*w/tˆy-v

ˆ /

)+

Solucion 1 -> vytˆw/zx+*-

Solucion 2 -> -*+xz/wˆtyv

-

*

- -ˆ

-/

-*

-*)

-*)

+

-*

- ˆ/ *

) + (

Ejemplos

(A+B*C)/D*Kˆ1

Solucion 1 -> 1KˆD*CB*A+/

Solucion 2 -> /+A*BC*DˆK1

Transformación de expresiones infijas en expresiones prefijas Expresión en infija: A*(B+C-(A+B/C)-A)-B

Simbolo PILA Expresion P

B-)A-)C/B+A(-C+B(*A

-- )- )- ) -- ) - )- ) - )- ) - ) /- ) - ) /- ) - ) +- ) - ) +- ) -- ) -- ) -- ) +- ) +-- *- *

BBBB AB AB AB A CB A CB A C BB A C B /B A C B / AB A C B / A +B A C B / A + -B A C B / A + - CB A C B / A + - C -B A C B / A + - C - BB A C B / A + - C - B +B A C B / A + - C - B +B A C B / A + - C - B + AB A C B / A + - C - B + A * -

Evaluación de expresiones postfijas

Infija => 5*(6+2)-12/4 Postfija => 5,6,2,+,*,12,4,/,-

Símbolo PILA

5

6

2

+

*

12

4

/

-

5

5 6

5 6 2

5 8

40

40 12

40 12 4

40 3

37

Evaluación de expresiones postfijas

Infija => 5*(6+2)-12/4 Símbolo PILA1 PILA2

5*(6+2)-

12/4

5555 65 65 6 25 84040 1240 1240 12 440 337

** (* ( +* ( +* ( +*---/-/-

Tarea: Calculadora Elaborar un programa en java para hacer la conversión

de infija a posfija y prefija (CALCULADORA)Ejemplo:Dame expresion a convertir => a+b

Expresion en postfijo => ab+Expresion en prefijo1 => ba+Expresion en prefijo 2 => +ab

Después de la conversión, se pida una expresión en prefija y evaluar

Crear una calculadora con las operaciones de +,-,/,* de expresiones infijas, evaluación de cada una de las expresiones y las opciones de conversión a postfijo y prefijo así como su evaluación.

00

44

332211

6655

998877

PrefPref

==

PostPost

Pilas

Technology

Transcript of Pilas