Universidad Nacional de Trujillo

Escuela de Ingeniería de Sistemas

Algoritmos y Estructuras de Datos

TEMA: Notaciones Infix, Prefix y Postfix de las expresiones aritméticas

Integrantes:
 ROMERO ARCE JHORDAN MARTIN
 ARGOMEDO DE LA CRUZ JHON

Docente:
 ZORAIDA YANET VIDAL MELGAREJO

Trujillo-Diciembre
2017

1
INDICE
RESUMEN ...................................................................................................................................... 3
INTRODUCCIÓN ............................................................................................................................ 3
PILA ........................................................................................................................................... 3
Evaluación de expresiones aritméticas Infija, prefija y postfija ............................................. 4
Notación Infija ...................................................................................................................... 4
Notación Prefija o Polaca ..................................................................................................... 4
Notación postfija .................................................................................................................. 5
Conversión general de infijo a posfijo ......................................................................................... 7
Evaluacion de la notación en el lenguaje de C++......................................................................... 9
CONCLUSIONES ........................................................................................................................... 12
REFERENCIAS BIBLIOGRAFICAS .................................................................................................. 13

2
RESUMEN
Una estructura de datos es una colección de datos organizados de un modo particular. Las
estructuras de datos pueden ser de dos tipos: estructuras de datos estáticas y estructuras de
datos dinámicas o bien estructuras lineales o no lineales.
Las estructuras de datos estáticas son aquellas en las que se asigna una cantidad fija de memoria
cuando se declara la variable, en numerosas ocasiones se necesitan, colecciones de datos que
crezcan y reduzcan su tamaño en memoria a medida que el programa progresa, a estas
estructuras de datos cuya ocupación en memoria puede aumentar o disminuir en tiempo de
ejecución se denominan estructuras dinámicas de datos.

Son Estructuras Lineales en los que los distintos elementos se sitúan en línea, de ahí su nombre.
Cada elemento de una estructura lineal, excepto el primero y el último, tienen un anterior y un
siguiente.
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.

El componente básico de una estructura de datos es la celda. Se puede representar una celda
como una caja capaz de almacenar un valor tomado de algún tipo de datos básico o compuesto,
las estructuras de datos se crean dando nombres a agregados de celdas.
El mecanismo de agregación más sencillo en C y en la mayor parte de los lenguajes de
programación es el arreglo (unidimensional), que es una sucesión de celdas de un tipo dado al
cual se llamará casi siempre <<tipo_celda>>.

INTRODUCCIÓN
PILA
Una pila (stack) es un tipo fundamental de lista (Tipo de dato abstracto fundamental) en la que
todas las inserciones y supresiones de elementos solo se pueden realizar desde una única
posición, el extremo, la cima o tope de la pila (TOP).
El modelo intuitivo de una pila es precisamente una pila de monedas puestas sobre una mesa,
o de cajas sobre el piso, o de bandejas en una estantería, situaciones todas en las que solo es
conveniente quitar o agregar un objeto del extremo superior de la pila, al que se denominara en
lo sucesivo tope.

Dado que las operaciones de añadir solo se realizan por el extremo superior de la pila, 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), ya que el último
elemento en entrar será el primero en salir.
Las tres operaciones más importantes un 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.

3
Evaluación de expresiones aritméticas Infija, prefija y postfija
Una expresión aritmética está formada por operandos y operadores, como por ejemplo:

(a+b) - c*d
En este caso +, -, * son los operadores y a, b, c, d los operandos. Los operandos pueden ser
valores, variables o incluso otras expresiones, mientras que los operadores son los conocidos de
las expresiones matemáticas, por lo que el resultado puede ser de tipo numérico o variables.
La forma habitual que tenemos de escribir las operaciones matemáticas es poniendo el operador
entre dos operando, y que puede llevar paréntesis para encerrar subexpresiones con mayor
prioridad en cada operación, al igual que los operadores tienen cada uno una prioridad
diferente, ya que, por ejemplo, la multiplicación * tienen prioridad sobre la suma +.Veamos el
grado de prioridad de estos operadores.
1. Paréntesis ( )
2. Potencial ^
3. Producto/cociente * /
4. Suma/resta + -

Existen otras formas de escribir expresiones aritméticas, en el que se diferencian por la situación
de los operadores respecto de los operandos.
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 refiere 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:
3*4=12

3*4+2=14

3*(4+2)=18

Ventajas:

 En la notación infija la notación habitual es el primer operando, operador, segundo

operando y así sucesivamente.
 Es la notación ya vista que sitúa el operador entre sus operandos.
 Es la forma natural de escribir expresiones aritméticas.
Desventajas:
 Muchas veces necesita de paréntesis para indicar el orden de evaluación: A*B/(A+C) ≠
A*B/A+C

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.

4
  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 prefija: El orden es operador, primer operando, segundo operando

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*

Cuando escribe una expresión aritmética como B * C, la forma de la expresión le proporciona

información para que pueda interpretarla correctamente. En este caso, sabemos que la variable
B se está multiplicando por la variable C, ya que el operador de multiplicación * aparece entre
ellos en la expresión. Este tipo de notación se conoce como infijo ya que el operador se
encuentra entre los dos operandos en los que está trabajando.

Considere otro ejemplo infijo, A + B * C. Los operadores + y * todavía aparecen entre los
operandos, pero hay un problema. ¿En qué operandos trabajan? ¿Funciona el + en A y B o el *
toma B y C? La expresión parece ambigua.

Cada operador tiene un nivel de precedencia. Los operadores de mayor precedencia se usan
antes que los operadores de menor precedencia. Lo único que puede cambiar ese orden es la
presencia de paréntesis. El orden de precedencia para los operadores aritméticos coloca la
multiplicación y la división por encima de la suma y la resta. Si aparecen dos operadores de igual
precedencia, se usa un ordenamiento de izquierda a derecha o asociatividad.

Interpretemos la expresión problemática A + B * C usando la precedencia del operador. B y C se

multiplican primero, y A se agrega a ese resultado. (A + B) * C forzaría la adición de A y B antes
de la multiplicación. En la expresión A + B + C, por precedencia (a través de la asociatividad), el
extremo más a la izquierda se haría primero.

Las computadoras necesitan saber exactamente qué operadores realizar y en qué orden. Una
forma de escribir una expresión que garantice que no habrá confusión con respecto al orden de
las operaciones es crear lo que se llama una expresión totalmente entre paréntesis. Este tipo de

5
expresión usa un par de paréntesis para cada operador. Los paréntesis dictan el orden de las
operaciones; no hay ambigüedad Tampoco es necesario recordar ninguna regla de precedencia.

La expresión A + B * C + D se puede reescribir como ((A + (B * C)) + D) para mostrar que la

multiplicación ocurre primero, seguida de la suma más a la izquierda. A + B + C + D se puede
escribir como (((A + B) + C) + D) ya que las operaciones de adición se asocian de izquierda a
derecha.

Hay otros dos formatos de expresión muy importantes. Considere la expresión infija A + B. ¿Qué
pasaría si moviéramos al operador antes de los dos operandos? La expresión resultante sería +
A B. Del mismo modo, podríamos mover el operador hasta el final. Obtendríamos A B +. Estos
se ven un poco extraños.

Estos cambios en la posición del operador con respecto a los operandos crean dos nuevos
formatos de expresión, prefijo y postfijo. La notación de expresión de prefijo requiere que todos
los operadores precedan a los dos operandos en los que trabajan. Postfix, por otro lado, requiere
que sus operadores vengan después de los operandos correspondientes. Algunos ejemplos más
deberían ayudar a aclararlo un poco (ver Tabla 1).

Tabla 1

Expresion Infix Expresion Prefix Expresion Postfix

A+B +AB AB+

A+B*C +A*BC ABC*+

A + B * C se escribiría como + A * B C en el prefijo. El operador de multiplicación aparece

inmediatamente antes de los operandos B y C, lo que denota que * tiene prioridad sobre +. El
operador de suma aparece entonces antes de A y el resultado de la multiplicación.

En postfix, la expresión sería A B C * +. De nuevo, el orden de las operaciones se conserva porque

el * aparece inmediatamente después de B y C, lo que denota que * tiene prioridad, con +
después. Aunque los operadores se movieron y ahora aparecen antes o después de sus
respectivos operandos, el orden de los operandos permaneció exactamente igual entre ellos.

Ahora considere la expresión de infijo (A + B) * C. Recuerde que en este caso, infijo requiere los
paréntesis para forzar el rendimiento de la suma antes de la multiplicación. Sin embargo, cuando
A + B se escribía en el prefijo, el operador de suma simplemente se movía antes de los
operandos, + A B. El resultado de esta operación se convierte en el primer operando para la
multiplicación. El operador de multiplicación se mueve delante de toda la expresión, dándonos
* + A B C. Del mismo modo, en postfix A B + obliga a que la suma suceda primero. La
multiplicación se puede hacer para ese resultado y el operando restante C. La expresión de
postfijo adecuada es A B + C *.

6
Considere estas tres expresiones nuevamente (Tabla 2). Algo muy importante ha sucedido. ¿A
dónde fueron los paréntesis? ¿Por qué no los necesitamos en prefijo y postfix? La respuesta es
que los operadores ya no son ambiguos con respecto a los operandos en los que trabajan. Solo
la notación infija requiere los símbolos adicionales. El orden de las operaciones dentro de las
expresiones prefijo y postfijo está completamente determinado por la posición del operador y
nada más. En muchos sentidos, esto hace que infix sea la notación menos deseable para usar.

Tabla 2

Expresion Infix Expresion Prefix Expresion Postfix

(A + B) * C *+ABC 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 8 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 guardara 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.
Sin embargo si la cima de la pila es un operador de mayor o igual prioridad, entonces
tendremos que sacar los operadores de la pila uno a uno y los escribiremos en el array
o fichero hasta que en la cima haya en operador de menor prioridad, un paréntesis de
apertura o hasta que la pila quede vacía. Será entonces cuando metamos el operador.

7
 De esta forma nos aseguramos de que las operaciones con mayor prioridad se realizan
anteriormente, pues sus operadores son los que antes salen de la pila.
 Si es un paréntesis tendremos que distinguir los dos casos existentes:
Si es un paréntesis de apertura se mete en la pila, se considerara de menor prioridad
para todo.
Cuando se lee el otro paréntesis de clausura hay que sacar todos los operadores de la
pila que pasaran a formar parte de la notación postfija hasta llegar al paréntesis de
apertura, que se eliminara, ya que los paréntesis no forman parte de la notación postfija.
De esta forma aseguramos que las operaciones contenidas en un paréntesis van a ser
agrupadas.

El proceso se termina cuando ya no hay más ítems que leer, y es entonces cuando sacamos uno
a uno los operadores que pudieran quedar en la pila y los escribimos al final de nuestro array o
fichero. Todo habrá concluido cuando no haya nada más que leer y la pila este vacía.

En estos casos también es conveniente utilizar pilas implementadas mediante listas enlazadas,
ya que no sabemos cuál va a ser la longitud de la pila y si utilizamos un vector podemos
quedarnos cortos o pasarnos de largo.

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 el ( 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.

8
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^/

abc+def^/-g el –se compara con la cima de la pila, que al ser de igual prioridad se escribe
en el array o fichero y en – se mete en la pila.

abc+def^/-g- al terminar el otro paréntesis, escribimos todo lo que hay en la pila hasta
llegar al paréntesis de apertura. La pila será ahora de la forma:

Como ya no hay más ítems escribimos el contenido de la pila al final de la notación postfija, y
la pila quedará vacía, y el resultado será: ab +def^/-g-*

Evaluacion de la notación en el lenguaje de C++

//Definición de la Clase Estructura:

class Pila

public:
int tamano;
int top;
char datos[50];

public:

Pila(void)

};

9
//CREACIÓN DE LA CLASE PROCESO: MiPila
#pragma once
#include "Pila.h"
class MiPila
{
public:
void Push(Pila &, char);
char Pop(Pila &);
char Top(Pila);
char Evaluar(char);
int Prior(char, int);

MiPila(void)
{
}
};

void MiPila::Push(Pila &P, char xdato)

{
if(P.tamano>P.top)
{
P.top++;
P.datos[P.top]=xdato;
}
}
char MiPila::Pop(Pila &P)
{
char wdato=' ';
if(P.top > -1)
{
wdato=P.datos[P.top];
P.top--;
}
return(wdato);
}

char MiPila::Top(Pila P)
{
char wdato= ' ';
if(P.top > -1)
wdato=P.datos[P.top];
return(wdato);
}

char MiPila::Evaluar(char elemento)

{
if(elemento=='^'||elemento=='*'||elemento=='/'||elemento=='+'||elemento=='-')
return('r');
if(elemento=='('||elemento==')')
return(elemento);
else
return('n');
}

10
int MiPila::Prior(char simbolo, int n)
{
if(simbolo=='^')
return(3);
if(simbolo=='*'||simbolo=='/')
return(2);
if(simbolo=='+'||simbolo=='-')
return(1);
if(simbolo==')'||simbolo=='#')
return(0);
if(simbolo=='('&&n==1)
return(4);
if(simbolo=='('&&n==2)
return(0);
}

//IMPLEMENTACIÓN DEL CÓDIGO EN EL FORMULARIO

Pila P;
P.tamano=50;
P.top=-1;

for(int k=0; k<50; k++)

P.datos[k]=' ';

MiPila PILA;
PILA.Push(P, '#');

int longitud=textINFIX->Text->Length;
char INFIX[50], POSTFIX[50];

for(int k=0; k<50; k++)

INFIX[k]=' ';

String^ Infija = textINFIX->Text;

for(int k=0; k<longitud; k++)

{
INFIX[k]=Convert::ToChar(Infija->Substring(k,1));
}

int m=0, z=0;

while(m<longitud)
{
char elemento=INFIX[m];
if(PILA.Evaluar(elemento)=='n')
{
POSTFIX[z]=elemento;
z++;
}

11
if((PILA.Evaluar(elemento)=='r')||(PILA.Evaluar(elemento)=='('))
{
while(PILA.Prior(elemento,1)<PILA.Prior(PILA.Top(P),2))
{
POSTFIX[z]=PILA.Pop(P);
z++;
}
PILA.Push(P, elemento);
}

if(PILA.Evaluar(elemento)==')')
{
while(PILA.Top(P)!='(')
{
POSTFIX[z]=PILA.Pop(P);
z++;
}
char xx=PILA.Pop(P);
}
m++;
}

while(PILA.Top(P)!='#')
{
POSTFIX[z]=PILA.Pop(P);
z++;
}

// Pasando el array de Postfix a la caja de texto

textPOSTFIX->Text="";
String^ Postfija="";

for(int w=0; w<longitud; w++)

Postfija+=Char::ToString(POSTFIX[w]);
textPOSTFIX->Text = Postfija;
}

};
}

CONCLUSIONES
Para concluir tenemos que las pilas las listas enlazadas, todos sus métodos y las diferentes
expresiones son una de las herramientas utilizadas para programar y procesar de una manera
automatizada todos los sistemas que usamos DIA tras DIA en relación a técnicas o métodos para
agilizar operaciones se refiere, es su principio fundamental dar soluciones a procesos que
ameritan de largos pasos que dan como resultado el control de un asusto. Estas herramientas
son uno de los instrumentos más usados en la programación para estructurar y organizar
información.

12
REFERENCIAS BIBLIOGRAFICAS
Algoritmos y Estructuras de Datos (Bottazzi, Cristian.)

Problem Solving with Algorithms and Data Structures

http://www.monografias.com

https://www.infor.uva.es

13