Este documento describe diferentes estructuras de datos, incluyendo lineales como pilas, colas y listas, y no lineales como árboles. Explica el almacenamiento contiguo y no contiguo de datos, y cómo las estructuras de datos se pueden usar para organizar datos y programas en la memoria RAM.

1. Estructuras de Datos
Almacenamiento
Contiguo
Lineales
Estructura Pilas,cola Almacenamiento
s,listas
s de Datos No Contiguo
No lineales
árboles

2. Memoria
Stack
Programas (Pila)
Datos
Memoria RAM
Video
Heap
(montón Buffer
)

3. Memoria
0 1 2 3 4
V
2 2 2 2 2 Bytes por elemenrto
D1 d2 D3 d4 D5 d6 D7 d8 D9 d10 Dirección de memoria
1 2 3 4 5 6 7 8 9 10
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, DI + 3 * 2 = 1+3*2= 1+6= 7
Observe que el tercer elemento del arreglo inicia en la dirección 7.

4. 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 Clave Clave Clave
Edad Edad Edad Edad
Estatur Estatur Estatur Estatur
a a a a
•Definir una clase que contenga los atributos que deseamos
class dato
{ public int clave;
public int edad;
public float estatura;
}

5. Memoria
• Definir el arreglo V Dirección
Memoria
dato [ ] v = new dato[5]
null null null null null
• Crear a cada elemento un objeto donde estarán los datos
Dirección
for( int i=0 ; i<5 ; i++) Memoria
v[i]=new dato();
Clave
Clave
Edad
Edad
Estatura Clave
Estatura Edad
Estatura Clave
Edad
Clave
Estatura
Edad
Estatura

6. Memoria
for( i=0 ; i<5 ; i++) V Dirección
Memoria
{ v[i].clave=i+1;
v[i].edad=i*10;
v[i].estatura=i+0.5;
Clave=4
Clave=1
} Edad=0
Edad=30
Estatura=3.5 Clave=5
Estatura=0.5 Edad=40
Estatura=4.5 Clave=2
Edad=10
Clave=3
Estatura=1.5
Edad=20
Estatura=2.5

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

8. 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.

9. NOTACIONES:
 Notaciones matemáticas
 Funció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

10. NOTACIONES:
 Notaciones matemáticas
 Simbolo de la suma (sumatorio)
El simbolo sumatorio es ∑
Ejemplo:
Sea la secuencia a1, a2, a3, a4,……..an
Las sumas n
a1+a2+a3+a4+ ……. +an = ∑ a
J=1

11. NOTACIONES:
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+

12. 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.

13. 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.

14. 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).

15. Ejemplo:
Insertar Insertar Insertar Eliminar
Inicio: A: B: C:
C
B B B
A A A A
Tope Null Tope Tope Tope Tope
tope tope tope tope
tope

16. pila
xxx yyy zzz
1 2 3 4 5 6 7 8
Cima 3 maxpila 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?

17. Realizar el siguiente Ejercicio
Dibuje 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

18. 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

19. 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();
}

20. 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 pila
esta llena

21. Ejercicio
 Hacer el método para el algoritmo
pila_vacia
 Realizar el método para pila_llena

22. Algoritmo para insertar un
elemento de la pila
insertar_push (int elem); public void push (int elem)
Verificar si la si la esta llena {
Si la pila esta llena; enviar mensaje de que if (this.llena())
esta llena ERROR
Si no else{
• se prepara a insertar, tope ++;
incrementando el tope de la pila pila [ tope ] = elem;
• se inserta el elemento en la pila }
}
{fin del condicional}
Hacer el algoritmo para insertar un
elemento a la pila

23. Algoritmo para retirar un elemento
de la pila
public int pop()
Retirar_pop (int elem); {
Verificar si la pila esta vacia if (this.vacia())
Si esta vacia; enviar mensaje de que esta ERROR
llena else{
Si no int x = pila[tope];
se respalda el elemento a eliminar tope --;
se decrementa el tope de la pila return x;
se regresa el valor eliminado de la pila }
{fin del condicional} }
Hacer el algoritmo para retirar un elemento
a la pila

24. Implementación usando un arreglo:
class Pila {
int tope = -1; public boolean vacia(){
private int [] pila = new int [10]; return (tope == -1);
final int max = 9; }
public boolean llena(){ public int pop(){
return ( tope == max); if (this.vacia())
} ERROR
public void push (int elem){ else{
if (this.llena()) int x = pila[tope];
ERROR tope --;
else{ return x;
tope ++; }
pila [ tope ] = elem; }
} }
}

25. public class Stack {
private Vector items; Implementación usando un
public Stack() {
items = new Vector(10);
Vector
}
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;
}
}

26. class Pilas_Mias Ejemplo de la implementación de la clase pila
{
private boolean Pila_vacia() {
private Object pila[];
boolean res=false;
private int tope=-1;
if(tope==-1)
private Object dato;
res=true;
private int max=0;
return res;
Pilas_Mias(int maximo){
}
max=maximo;
pila=new Object[max];
public boolean Insertar_pila(Object dato)
}
{
boolean res=false;
public void borrarpila() {
if(!Pila_llena()) {
tope=-1;
tope++;
}
pila[tope]=dato;
res=true;
private boolean Pila_llena() {
}
boolean res=false;
return res;
if(tope==(max-1)) {
}
res= true;
}
else {
res= false; }
return res;
}

27. 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]);
}
}
}

28. pila1.Insertar_pila("hola");
pila1.Insertar_pila(333);
pep
pila1.Insertar_pila(“pepe");
333 e
333
pila1.Insertar_pila(444);
hola hola hola
pila1.Mostrar(); T -1 T0 T2
T1
pila1.Insertar_pila(“ana”); ana
pila1.retirar_pila(); 444 444 444
pep pep pep
pila1.Mostrar(); e e e
333 333 333
//pila1.borrarpila();
hola hola hola
retirar_pila(); T3 T4 T3
pila1.Mostrar();
pila1.retirar_pila();
pila1.Insertar_pila(“nuevo"); pep nuevo
e
333 333 333
pila1.Mostrar(); hola hola
hola
Max=5 T1 T2
T2

29. La pila puede representarse por
medio de:
Max = 5
 Arreglos (memoria estática)
Una vez definido el tamaño del tope c
arreglo no se cambia su tamaño b
a
pila
 Listas enlazadas (memoria
tope
dinámica)
Se almacenan los elementos como
nodos y el tamaño se ajusta c b a
exactamente a los elementos de
la pila
pila
d

30. 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

31. Ejemplo invertir cadena
import 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));}
}

32. 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();
}
}

33. 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

34. public class palindromo
{
public static void main(String args[]) throws IOException PALINDROMO
{
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));
}
}

35. System.out.println();
pila1.MostrarOri();
PALINDROMO
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);}
}
}

36. De acuerdo al siguiente algoritmo,
realizar el programa en java
Algoritmo palindromo2
Var
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

37. 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");
}
}

38. Aplicaciones de Pilas
Evaluació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ía
2. Que no quede ningún paréntesis que cierre pendiente
Ejemplo con las operaciones anteriores

39. Evaluar los parentesis
Expresion = ([(A+B)*(C+D)])
( [ ( ) (
( (
[ [ [ [
( ( ( ( (
T 0 T 1 T 2 T 1 T 2
) ] )
[
( (
T 1 T 0 T -1

40. 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

41. 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");
}
}
}

42. Resultados Correcto e incorrecto

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

44. Aplicaciones de Pilas
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.

45. PRESEDENCIA OPERADORES :
() paréntesis Nivel mayor prioridad
^ potencia
* / multiplicación, división
+,- suma, resta Nivel menor prioridad

46. NOTACIONES:
NOTACION INFIJA:
es la forma habitual de escribir operaciones
aritméticas es la de situar el operador entre sus dos
operandos. El operador se evalúa dentro de los
Operandos.
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

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

48. 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

49. De infija a prefija
A*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
De infija a postfija
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+

50. 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

51. Transformación de expresiones infijas en
expresiones postfijas
 Expresión en infija: A+(B*C-(D/E^F)*G)*H
Simbolo PILA Expresion P
A A
+ + A
( +( A
B +( AB
* +(* AB
C +(* ABC
- +(- ABC*
( +(-( ABC*
D +(-( ABC*D
/ +(-(/ ABC*D
E +(-(/ ABC*DE
^ +(-(/^ ABC*DE
F +(-(/^ ABC*DEF
) +(- ABC*DEF^/
* +(-* ABC*DEF^/
G +(-* ABC*DEF^/G
) + ABC*DEF^/G*-
* +* ABC*DEF^/G*-
H +* ABC*DEF^/G*-H
ABC*DEF^/G*-H*+

52. 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
-
(
*

53. Expresión A* (B+C-(D/E ˆF)-G)-H
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 -
-

54. REGLAS PARA CONVERTIR EXPRESION INFIJA A
POSTFIJA
Se 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.

55. Resultados de infijo a postfijo
(a+b)*c-b
a*(b+c-(a+b/c)-a)-b

56. 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

57. Ejemplos +
(x+z)*w/tˆy-v )
*
/
/ ) + ( ˆ
- ˆ * -
+
) )
ˆ / * * * *
- - - - - - -
Solucion 1 -> vytˆw/zx+*-
Solucion 2 -> -*+xz/wˆtyv

58. Ejemplos
(A+B*C)/D*Kˆ1
Solucion 1 -> 1KˆD*CB*A+/
Solucion 2 -> /+A*BC*DˆK1

59. 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 B
- - B
) - ) B
A - ) BA
- - )- BA
) - )-) BA
C -)-) BAC
/ -)-)/ BAC
B -)-)/ BACB
+ -)-)+ BACB/
A -)-)+ BACB/A
( -)- BACB/A+
- -)- BACB/A+-
C -)- BACB/A+-C
+ -)+ BACB/A+-C-
B -)+ BACB/A+-C-B
( - BACB/A+-C-B+
* -* BACB/A+-C-B+
A -* BACB/A+-C-B+A
BACB/A+-C-B+A*-

60. Evaluación de expresiones postfijas
 Infija => 5*(6+2)-12/4
 Postfija => 5,6,2,+,*,12,4,/,-
Símbolo PILA
5 5
6 56
2 562
+ 58
* 40
12 40 12
4 40 12 4
/ 40 3
- 37

61. Evaluación de expresiones postfijas
 Infija => 5*(6+2)-12/4
Símbolo PILA1 PILA2
5 5
* 5 *
( 5 *(
6 56 *(+
+ 56 *(+
2 562 *(+
) 58 *
- 40 -
12 40 12 -
/ 40 12 -/
4 40 12 4 -/
40 3 -
37

62. 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.

63. 1 2 3
4 5 6
7 8 9
0 =
Post Pref