NOTACIONES INFIX, PREFIX Y

POSTFIX DE LAS EXPRESIONES

ARITMÉTICAS
LAS ESTRUCTURAS LINEALES SON LAS LISTAS, PILAS Y COLAS.

LA DIFERENCIA ENTRE ESTOS TRES TIPOS DE ESTRUCTURAS LINEALES ES EL MODO DE ACCESO

A LOS ELEMENTOS QUE LA INTEGRAN:

 EN UNA LISTA, LOS ELEMENTOS PUEDEN AÑADIRSE Y BORRARSE EN CUALQUIER POSICIÓN.

 EN UNA COLA, LOS ELEMENTOS PUEDEN AÑADIRSE POR UN EXTREMO Y BORRARSE

POR EL OTRO.
 EN UNA PILA LOS ELEMENTOS SÓLO PUEDEN AÑADIRSE Y BORRARSE POR UNO DE SUS
EXTREMOS.
 PILA (STACK)

LOS ELEMENTOS SOLO SE PUEDEN

ELIMINAR EN ORDEN INVERSO A COMO
HAN SIDO INSERTADOS EN LA PILA. POR
ESTA RAZÓN A LAS PILAS SE LAS
CONOCE COMO LISTAS LIFO (LAST INPUT,
FIRST OUTPUT),
 LAS TRES OPERACIONES MÁS IMPORTANTES EN UNA PILA SON:

 PUSH: Meter, poner, apilar. Operación que inserta un elemento en

la sima de la pila.
 POP: Sacar, quitar. Operación que elimina el elemento que ocupaba
la posición cima. El elemento que había sido insertado
inmediatamente antes que el eliminado pasara a ser ahora la nueva
posición cima.
 TOPE: Operación que devuelve el elemento que ocupa en ese
instante la posición cima, pero sin extraerlo.
VEAMOS EL GRADO DE PRIORIDAD DE
LOS OPERADORES:

• Potencial
• Producto/cociente
• Suma/resta
• Paréntesis
 NOTACIÓN INFIJA

La Expresión o Notación InFija es la forma más común que utilizamos

para escribir expresiones matemáticas, estas notaciones se refieren a
que el operador esta entre los operandos. La notación infija puede
estar completamente parentizada o puede basarse en un esquema de
precedencia de operadores, así como el uso de paréntesis para
invalidar los arreglos al expresar el orden de evaluación de una
expresión:
 OBTENER LA
NOTACIÓN
INFIJA DEL
SIGUIENTE
ARBOL
 NOTACIÓN PREFIJA O POLACA

La Expresión o Notación Prefija nos indica que el operador va antes de los operandos. Sus
características principales son:
• Los operandos conservan el mismo orden que la notación infija equivalente.
• No requiere de paréntesis para indicar el orden de precedencia de operadores ya que
es una operación.
• Se evalúa de izquierda a derecha hasta que encontrémosle primer operador seguido
inmediatamente de un par de operandos.
• Se evalúa la expresión binaria y el resultado se cambia como un nuevo operando. Se
repite este hasta que nos quede un solo resultado.
• Ejemplo: la expresión infija A*B / (A+C) se representaría en notación
prefija como:

/*AB+AC
 NOTACIÓN POSTFIJA

Como su nombre lo indica se refiere a que el operador ocupa la posición

después de los operandos sus características principales son:

• El orden de los operandos se conserva igual que la expresión infija equivalente no

utiliza paréntesis ya que no es una operación ambigua.
• La operación posfija no es exactamente lo inverso a la operación prefija equivalente.
• El orden es primer operando, segundo operando, operador.
EJEMPLO:

SI DESEAMOS REPRESENTAR LAS EXPRESIONES (2+(3*4)) = X Y ((2+3) *4)

EN LAS TRES NOTACIONES MENCIONADAS, EL RESULTADO SERÍA:

(2+(3*4)) ((2+3) *4)

Notación prefija
+2*34 *+234
Notación infija
2+3*4 (2+3) *4
Notación postfija
234*+ 23+4*
TABLA 1

Expresión Expresión Expresión Postfix

Infix Prefix
A+B +A B AB+

A+B*C +A * B C ABC*+
TABLA 2

Expresión Expresión Expresión Postfix

Infix Prefix

(A + B) * C * +A B C AB+C*
CONVERSIÓN DE EXPRESIONES INFIX A PREFIX Y
POSTFIX

• Aquí hay una expresión más compleja: (A + B) * C - (D - E) * (F + G).

• La Figura muestra la conversión a notaciones de prefijo y postfijo.
CONVERSIÓN GENERAL DE INFIJO A POSFIJO

• Partimos de una expresión con notación infija que tiene operadores y operandos, que queremos
transformar en una notación postfija.
• La transformación se realiza mediante la utilización de una pila en la que se van metiendo los
operadores y los paréntesis izquierdos. La expresión aritmética se va leyendo carácter a carácter
y va guardándose en una pila o en un array, según de lo que se trate, de la siguiente forma:
• Si es un operando, se guardará directamente en el array o en un fichero.
• Si es un operador y la pila está vacía, lo meteremos en la pila. Si la pila no está vacía, tendremos que
distinguir el grado de prioridad de dicho operador. Por lo tanto:

• Si la cima de la pila es un operador de menor prioridad, entonces lo meteremos en la pila.

• Veamos algún ejemplo que nos aclare las cosas:

a*(b+c-(d/e^f)-g)

a el operando a pasa a un fichero o array, y * a la pila

ab pasa a la pila y el operando b pasa al fichero
abc el + pasa a la pila y el operando c se escribe en el fichero
• La pila tiene la siguiente forma:

Se nos presenta el problema del -, que como tiene igual prioridad que el +
se saca +, se escribe en el fichero y se mete – en la pila.
• abc+ el ( se escribe en la pila
• abc+de el operando d pasa al array, el / a la pila, y e pasa al array
• abc+def ^ lo metemos en la pila, y f lo escribimos en el fichero.

Ahora se cierra un paréntesis y tenemos la siguiente pila

Luego nuestra expresión quedará, tras haber sacado los operadores

hasta paréntesis y eliminándolo después de haberlo sacado así:
abc+def^/
 //CREACIÓN DE LA CLASE PROCESO: MIPILA
#pragma once
#include "EstructuraPila.h"
class OPERACIONES
{
public:
void Inicializar(EstructuraPila &);
void Push(EstructuraPila &, char);
char Pop(EstructuraPila &);
char Top(EstructuraPila);
char Evaluar(char);
int Prior(char, int);
OPERACIONES()
{
}
};
 else
int OPERACIONES::Prior(char elemento, int sw) {
{ if (elemento == '(' && sw == 1)
if (elemento == '^') return(4);
return(3); else
else{ {
if (elemento == '*' || elemento == '/') if (elemento == '(' && sw == 2)
return(2); return(0);
else }
{
if (elemento == '+' || elemento == '-') }
return(1);
else }
{
if (elemento == ')' || elemento == '#') }
return(0); }
}
char OPERACIONES::Evaluar(char elemento) char
{ OPERACIONES::Top(EstructuraPila P)
{
if (elemento == '^' || elemento == '*' || char xdato;
elemento == '/' || elemento == '+' || if (P.top > -1)
elemento == '-') xdato = P.datos[P.top];
else
return('r'); xdato = ' ';
return(xdato);
else if (elemento == '(' || elemento == ')')
}
return(elemento);
else
return('n');
}
char OPERACIONES::Pop(EstructuraPila &P) void OPERACIONES::Push(EstructuraPila &P, char xdato)
{ {
if (P.top < P.tamaño)
char xdato;
{
if (P.top > -1) P.top++;
{ P.datos[P.top] = xdato;
}
xdato = P.datos[P.top];
}
P.top--; void OPERACIONES::Inicializar(EstructuraPila &P)
} {
P.tamaño = 50;
else P.top = -1;
xdato = ' '; }
return(xdato);
}
 //IMPLEMENTACIÓN DEL CÓDIGO EN EL
FORMULARIO

private: System::Void BtnConvertir_Click(System::Object^ sender, System::EventArgs^ e)

{
OPERACIONES OP;
int largo = TxtINFIX->Text->Length;
String ^Infija = TxtINFIX->Text;
char INFIX[100];
for (int k = 0; k < largo; k++)
INFIX[k] = Convert::ToChar(Infija->Substring(k, 1));
int z = 0, n = 0;
char POSTFIX[100];
EstructuraPila P;
OP.Inicializar(P);
OP.Push(P, '#');
while (z < largo)
{
char elemento = INFIX[z];
if (OP.Evaluar(elemento) == 'n')
{
POSTFIX[n] = elemento;
n++;
}
if (OP.Evaluar(elemento) == 'r' || OP.Evaluar(elemento) == '(')
{
while (OP.Prior(elemento, 1) < OP.Prior(OP.Top(P), 2))
{
POSTFIX[n] = OP.Pop(P);
n++;
}
OP.Push(P, elemento);
}
if (OP.Evaluar(elemento) == ')') private: System::Void
{ BtnSalir_Click(System::Object^ sender,
while (OP.Top(P) != '(') System::EventArgs^ e)
{ {
POSTFIX[n] = OP.Pop(P); Close();
n++; }
}
char zz = OP.Pop(P);
}
z++;
}
while (OP.Top(P) != '#')
{
POSTFIX[n] = OP.Pop(P);
n++;
}
String ^Postfija = "";
for (int q = 0; q < n; q++)
Postfija += Char::ToString(POSTFIX[q]);
TxtPOSTFIX->Text = Postfija;
}
GRACIAS
INTEGRANTES:

• CHAMOCHUMBI APAESTIGUE WENDY

• HERNÁNDEZ GÓMEZ PIERO
• LOVÓN RODRIGUEZ JORGE
• LLIQUE CHÁVARRY JHON
• QUIRÓZ GAMARRA JOSÉ
• SILVA IZQUIERDO ANTOHNY
• ZAPATA YAMUNAQUÉ CESAR