7 Prog2 Tema2 Pilas

Contenidos 1
• El TAD Pila
• Estructura de datos y primitivas de Pila
• Implementación en C de Pila
• Implementación con top de tipo entero
Programación II • Ejemplos de aplicación de Pila
Tema 2. Pilas • Balanceo de paréntesis
• Evaluación de expresiones posfijo
• Conversión entre notaciones infijo, posfijo y prefijo
Iván Cantador y Rosa Mª Carro • Anexo

Escuela Politécnica Superior • Implementación con top de tipo puntero
Universidad Autónoma de Madrid
Programación II – Tema 2: Pilas
Escuela Politécnica Superior
Contenidos 2
El TAD Pila 3
• Pila (stack en inglés)

• El TAD Pila • Colección de elementos LIFO - Last In, First Out: “el último que
• Estructura de datos y primitivas de Pila entra, el primero que sale”
• Implementación en C de Pila
• Ejemplos de aplicación de Pila
• Balanceo de paréntesis
• Conversión entre notaciones infijo, posfijo y prefijo
• Anexo
• Implementación con top de tipo puntero
Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
El TAD Pila 4
El TAD Pila 5
• Definición de Pila • Aplicaciones reales de las pilas

• Contenedor de elementos que son insertados y extraídos • En general, todas aquellas aplicaciones que conlleven:
- estrategias “vuelta atrás” (back tracking): la acción deshacer/undo
siguiendo el principio de que el último que fue insertado será el
- algoritmos recursivos
primero en ser extraído (LIFO – Last In, First Out)
- Los elementos se insertan de uno en uno: push (apilar) • Ejemplos:
- Los elementos se extraen de uno en uno: pop (desapilar) - Editores de texto: pila con los últimos cambios realizados sobre un documento
- Navegadores web: pila de direcciones con los sitios web más recientemente
- El último elemento insertado (que será el primero en ser extraído) es el
visitados
único que se puede “observar” de la pila: top (tope, cima)
tiempo
- Pila de programa: zona de memoria de un programa donde se guardan
temporalmente los argumentos de entrada de funciones
push 1 push 2 push 3 pop 3 push 4 push 5 pop 5 pop 4 pop 2 pop 1
- Comprobación del balanceo de (), {}, [] en compiladores
- Parsing de código XML/HTML, comprobando la existencia de etiquetas de
5 comienzo <tag> y finalización </tag> de elementos en un documento XML
3 4 4 4 - Calculadoras con notación polaca inversa (posfijo): se convierten expresiones
2 2 2 2 2 2 2 “infijo” a “posfijo” soportando complejidad superior a la de calculadoras
1 1 1 1 1 1 1 1 1 algebraicas (p.e., realizan cálculos parciales sin tener que pulsar “=”)

Contenidos 6
Estructura de datos y primitivas de Pila 7
• Una pila está formada por:

• El TAD Pila • datos: conjunto de elementos, en general del mismo tipo, ordenados
• Estructura de datos y primitivas de Pila implícitamente y accesibles desde un único punto: el tope
• tope: indicador de la posición del último elemento insertado; da lugar
• Implementación en C de Pila a una ordenación LIFO (last in, first out)
• Implementación con top de tipo entero 7
• Ejemplos de aplicación de Pila 6
• Balanceo de paréntesis 5
4 x (en este dibujo asumimos que la pila

3 x tiene tamaño máximo de 8, pero no
• Conversión entre notaciones infijo, posfijo y prefijo tiene por qué ser siempre ese valor)
2 x
1 x
• Anexo
4 0 x
• Implementación con top de tipo puntero tope datos

• EdD en C
• datos: en este tema será un array de punteros: Elemento *datos[];
• top: en este tema se declarará de 2 maneras (versiones) distintas
• Primitivas
• V1: Como un entero: int top;
Pila pila_crear(): crea, inicializa y devuelve una pila • V2: Como un puntero a un elemento del array: Elemento **top;
pila_liberar(Pila s): libera (la memoria ocupada por) la pila
7 7
boolean pila_vacia(Pila s): devuelve true si la pila está vacía y false si no 6 6
boolean pila_llena(Pila s): devuelve true si la pila está llena y false si no x x
5 5
status pila_push(Pila s, Elemento e): inserta un dato en una pila 4 x 4 x

Elemento pila_pop(Pila s): extrae el dato que ocupa el top de la pila 3 x 3 x
2 2
Elemento pila_top(Pila s): devuelve el dato que ocupa el top de la pila sin x x
extraerlo de ella 1 1
x x
4 0 0
top datos top datos

Versión 1 Versión 2 (en anexo)
Contenidos 10
Implementación en C de Pila 11
• El TAD Pila
• Estructura de datos y primitivas de Pila • Implementación con top de tipo entero
• Asumimos la existencia del TAD Elemento
• Implementación en C de Pila 7
• EdD de Pila mediante un array
// En pila.h x
5
• Ejemplos de aplicación de Pila typedef struct _Pila Pila;
4 x
• Balanceo de paréntesis // En pila.c 3
#define PILA_MAX 8 x
• Evaluación de expresiones posfijo struct _Pila { 2
x
Elemento *datos[PILA_MAX];
• Conversión entre notaciones infijo, posfijo y prefijo 1
int top; x
}; 4 0
• Anexo top datos

• Implementación con top de tipo entero • Implementación con top de tipo entero
• Asumimos la existencia del TAD Elemento que, entre otras, • Asumimos la existencia del TAD Elemento que, entre otras,
tiene asociadas las primitivas liberar y copiar: tiene asociadas las primitivas liberar y copiar:
void elemento_liberar(Elemento *pe); void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe); Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en pila.h) • Primitivas (prototipos en pila.h)

Pila *pila_crear(); 7 Pila *pila_crear(); 7
void pila_liberar(Pila *ps); 6 void pila_liberar(Pila *ps); 6

boolean pila_vacia(const Pila *ps); x boolean pila_vacia(const Pila *ps); x
5 5
boolean pila_llena(const Pila *ps); boolean pila_llena(const Pila *ps);
status pila_push(Pila *ps, const Elemento *pe); 4 x status pila_push(Pila *ps, const Elemento *pe); 4 x
Elemento *pila_pop(Pila *ps); 3 Elemento *pila_pop(Pila *ps); 3
x x
• Estructura de datos (en pila.c) 2 • Estructura de datos (en pila.c) 2
x x
struct _Pila { 1 struct _Pila { 1
Elemento *datos[PILA_MAX]; x Elemento *datos[PILA_MAX]; x
int top; 4 0
int top; 4 0
}; top datos }; top datos

vacía Existe: void elemento_liberar(Elemento *pe);
Pila *pila_crear() {
Pila *ps = NULL; 7 7
int i;
6 void pila_liberar(Pila *ps) { 6
ps = (Pila *) malloc(sizeof(Pila)); int i;
5 5
if (ps == NULL) {
return NULL; 4 if (ps != NULL) { 4 x
} for (i=0; i<=ps->top; i++) {
3 3
elemento_liberar(ps->datos[i]); x
for (i=0; i<PILA_MAX; i++) { // Bucle opcional } 2
2
ps->datos[i] = NULL; free(ps); x
1 } 1
}
-1 0
}
4 0 x
ps->top = -1;
top datos top datos x
return ps;
}
ps ps
Existe: void elemento_liberar(Elemento *pe); Existe: void elemento_liberar(Elemento *pe);
7 7
void pila_liberar(Pila *ps) { 6 void pila_liberar(Pila *ps) { 6

int i; int i;
5 5
if (ps != NULL) { 4 x if (ps != NULL) { 4

for (i=0; i<=ps->top; i++) { for (i=0; i<=ps->top; i++) {
elemento_liberar(ps->datos[i]); 3 elemento_liberar(ps->datos[i]); 3
x
} 2
} 2
free(ps); x free(ps);
} 1 } 1
} x }
4 0 4 0
top datos x top datos
ps ps
• Asumimos la existencia del TAD Elemento que, entre otras, boolean pila_vacia(const Pila *ps) {
if (ps == NULL) { vacía
tiene asociadas las primitivas liberar y copiar: return NULL_BOOLEAN;
void elemento_liberar(Elemento *pe); } 7
Elemento *elemento_copiar(const Elemento *pe); 6
if (ps->top == -1) {
• Primitivas (prototipos en pila.h) return TRUE; 5
Pila *pila_crear(); 7 }
return FALSE; 4
void pila_liberar(Pila *ps); 6
} 3
boolean pila_vacia(const Pila *ps); x
5
boolean pila_llena(const Pila *ps); 2
status pila_push(Pila *ps, const Elemento *pe); 4 x
1
Elemento *pila_pop(Pila *ps); 3 x Nota: -1 0
• Estructura de datos (en pila.c) 2 Llamaremos a pila_vacia antes de hacer pop, comprobando si hay top datos
x
struct _Pila { 1 elementos en la pila. Si la pila está vacía, no llamaremos a pop.
Elemento *datos[PILA_MAX]; x Por eso, si ps es NULL, aquí detectamos el error y devolvemos
int top; 4 0
TRUE indicando que la pila “está” vacía, con el fin de que luego no ps
}; top datos se haga pop.
boolean pila_llena(const Pila *ps) { llena x • Asumimos la existencia del TAD Elemento que, entre otras,
if (ps == NULL) {
return NULL_BOOLEAN; 7
x tiene asociadas las primitivas liberar y copiar:
} 6 void elemento_liberar(Elemento *pe);
x Elemento *elemento_copiar(const Elemento *pe);
if (ps->top == PILA_MAX-1) { 5
return TRUE; 4 x • Primitivas (prototipos en pila.h)
} Pila *pila_crear(); 7
return FALSE; 3
x void pila_liberar(Pila *ps); 6
}
2 boolean pila_vacia(const Pila *ps); x
x 5
1
boolean pila_llena(const Pila *ps);
status pila_push(Pila *ps, const Elemento *pe); 4 x
Nota: 7 0 x
Elemento *pila_pop(Pila *ps); 3
Llamaremos a pila_llena antes de hacer push, comprobando si x
top datos x
la pila tiene o no capacidad. Si la pila está llena, no llamaremos a • Estructura de datos (en pila.c) 2
x
push. struct _Pila { 1
Por eso, si ps es NULL, aquí detectamos el error y devolvemos Elemento *datos[PILA_MAX]; x
ps int top; 4 0
TRUE indicando que la pila “está” llena, con el fin de que luego
no se haga push. }; top datos

status pila_push(Pila *ps, const Elemento *pe) { status pila_push(Pila *ps, const Elemento *pe) {
Elemento *aux = NULL; Elemento *aux = NULL;
if (ps == NULL || pe == NULL || pila_llena(ps) == TRUE) { if (ps == NULL || pe == NULL || pila_llena(ps) == TRUE) {
return ERR; aux return ERR; aux
} }
aux = elemento_copiar(pe); 7 push 7

aux = elemento_copiar(pe); 7 push 7
if (aux == NULL) { 6 if (aux == NULL) { 6
6 6
return ERR; return ERR;
} 5 5 e } 5 5 e
// Actualizamos el top 4 x 4 x // Actualizamos el top 4 x 4 x

ps->top++; ps->top++;
3 3 3 3
x x x x
// Guardamos el dato en el top 2 // Guardamos el dato en el top 2
2 2
ps->datos[ps->top] = aux; ps->datos[ps->top] = aux;
x x x x
1 1 1 1
return OK; return OK;
} 4 0 x 5 0 x } 4 0 x 5 0 x
e top datos x e top datos x e top datos x e top datos x

pe psUniversidad Autónoma de Madrid pe ps pe psUniversidad Autónoma de Madrid pe ps
• Asumimos la existencia del TAD Elemento que, entre otras, Elemento *pila_pop(Pila *ps){
Elemento *pe = NULL; pe
tiene asociadas las primitivas liberar y copiar:
void elemento_liberar(Elemento *pe); if (ps == NULL || pila_vacia(ps) == TRUE) {
return NULL;
Elemento *elemento_copiar(const Elemento *pe);
}
7 pop 7
• Primitivas (prototipos en pila.h) 6 6

// Recuperamos el dato del top
Pila *pila_crear(); 7 5 5
pe = ps->datos[ps->top];
void pila_liberar(Pila *ps); 6 4 e 4 e
boolean pila_vacia(const Pila *ps); x // Ponemos el Elemento* a NULL
5 ps->datos [ps->top] = NULL; 3 3
boolean pila_llena(const Pila *ps); x x
status pila_push(Pila *ps, const Elemento *pe); 4 x 2 2
// Actualizamos el top
Elemento *pila_pop(Pila *ps); 3
x x
x ps->top--; 1 1
• Estructura de datos (en pila.c) 2

return pe; 4 0 x 3 0 x
x
struct _Pila { 1 } top datos top datos
x x
Elemento *datos[PILA_MAX]; x
int top; 4 0
}; top datos
ps ps
Contenidos 27

Elemento *pila_pop(Pila *ps){ • El TAD Pila
if (ps == NULL || pila_vacia(ps) == TRUE) {
}
return NULL;
7 pop 7 • Implementación en C de Pila
6 6 • Implementación con top de tipo entero
5 5
pe = ps->datos[ps->top];
4 e 4 e
// Ponemos el Elemento* a NULL
ps->datos [ps->top] = NULL; 3 3
• Balanceo de paréntesis
x x
2 2 • Evaluación de expresiones posfijo
x x
ps->top--; 1 1 • Conversión entre notaciones infijo, posfijo y prefijo
4 0 x 3 0 x
return pe;
} top datos x top datos x • Anexo
Nota: el elemento cuyo puntero
se devuelve ha de liberarse fuera, • Implementación con top de tipo puntero
tras la llamada a pop ps ps
Balanceo de paréntesis 28
• Pseudocódigo (sin CdE)

boolean balanceoParentesis(CC S) {
p = pila_crear()
mientras (it=leerSimbolo(S)) ≠ FIN: // leer siguiente símbolo de S
si esParentesisApertura(it) // si it = (
• Determinar si una expresión (p.e., una operación pila_push(p,it)
si no, si esParentesisCierre(it) // si it = )
aritmética) contiene el mismo número de paréntesis de si pila_pop(p)=NULL
pila_liberar(p)
apertura que de cierre devolver FALSE
• Ejemplo 1: ( 3 * 4 / ( 6 - 1 ) )
( 3 * 4 / ( 6 - 1 ) ) CORRECTA si pila_vacia(p)=FALSE
Símbolo
Pila de
pila_liberar(p) paréntesis
2 + ( 5 / ( 4 + 7 ) INCORRECTA devolver FALSE (
3
(
(
pila_liberar(p)
* (
6 * 4 + 9 ) INCORRECTA devolver TRUE 4 (
} / (
( ((
6 ((
- ((
1 ((
) (
)

• Pseudocódigo (sin CdE) • Pseudocódigo (sin CdE)

p = pila_crear() 1 p = pila_crear()
mientras (it=leerSimbolo(S)) ≠ FIN: // leer siguiente símbolo de S si esParentesisApertura(it) // si it = (
si esParentesisApertura(it) // si it = (
pila_push(p,it)
2 pila_push(p,it)
si no, si esParentesisCierre(it) // si it = )
si no, si esParentesisCierre(it) // si it = ) si pila_pop(p)=NULL A
si pila_pop(p)=NULL A pila_liberar(p)
pila_liberar(p) devolver FALSE
devolver FALSE
• Ejemplo 1: ( 3 * 4 / ( 6 - 1 ) ) si pila_vacia(p)=FALSE • Ejemplo 1: ( 3 * 4 / ( 6 - 1 ) )
si pila_vacia(p)=FALSE B
B Símbolo
Pila de pila_liberar(p) Símbolo
Pila de
pila_liberar(p) paréntesis
devolver FALSE
paréntesis
devolver FALSE ( ( ( (
3 ( pila_liberar(p) 3 (
pila_liberar(p) devolver TRUE
* ( * (
devolver TRUE 4 ( } 4 (
} / ( / (
( ((
Posibles fuentes de error (funciones que pueden devolver ERROR): 1 2 ( ((
6 (( Errores de balanceo se detectan en: A B 6 ((
Errores de balanceo se detectan en: A B - (( - ((
1 (( • Ejemplo 2: 2 + ( 5 / ( 4 + 7 ) 1 ((
) ( ) (
) • Ejemplo 3: 6 * 4 + 9 ) )

• Pseudocódigo incompleto (solo mira paréntesis, sin CdE)

p = pila_crear()

• Determinar si una expresión (p.e. una operación si esParentesisApertura(it)
pila_push(p,it)
// si it = ‘(‘
aritmética) contiene el mismo número de paréntesis de si no, si esParentesisCierre(it) // si it = ‘)‘

si pila_pop(p)=NULL
apertura que de cierre, distinguiendo ‘()’, ‘{}’, ‘[]’ pila_liberar(p)
devolver FALSE
{ 3 * 4 / ( 6 - 1 ) } CORRECTA
si pila_vacia(p)=FALSE
2 + ( 5 / [ 4 + 7 ) ) INCORRECTA pila_liberar(p)
devolver FALSE
6 * 4 + 9 } INCORRECTA pila_liberar(p)
devolver TRUE
}


boolean balanceoParentesis(CC S) { boolean balanceoParentesis(CC S) {
p = pila_crear() p = pila_crear()
mientras (it=leerSimbolo(S)) ≠ FIN: // leer siguiente símbolo de S mientras (it=leerSimbolo(S)) ≠ FIN: // leer siguiente símbolo de S
si esSimboloApertura(it) // si es (, [ o { si esSimboloApertura(it) // si es (, [ o {
pila_push(p,it) pila_push(p,it)
si no, si esSimboloCierre(it) si no, si esSimboloCierre(it)
e = pila_pop(p) e = pila_pop(p)
si e=NULL O (it=')' Y e≠'(') si e=NULL O sonParentesisPareja(it,e)=FALSE
O (it=']' Y e≠'[') pila_liberar(p)
O (it='}' Y e≠'{') devolver FALSE
pila_liberar(p)
devolver FALSE si pila_vacia(p) = FALSE
pila_liberar(p)
si pila_vacia(p) = FALSE devolver FALSE
pila_liberar(p) pila_liberar(p)
devolver FALSE devolver TRUE
pila_liberar(p) }
devolver TRUE
}


boolean balanceoParentesis(CC S) { boolean balanceoParentesis(CC S) {
mientras (it=leerSimbolo(S)) ≠ FIN: // leer siguiente símbolo de S mientras (it=leerSimbolo(S)) ≠ FIN: // leer siguiente símbolo de S
si esSimboloApertura(it) // si es (, [ o { si esSimboloApertura(it) // si es (, [ o {
pila_push(p,it) 2 pila_push(p,it)
si no, si esSimboloCierre(it) si no, si esSimboloCierre(it)
A si e=NULL O sonParentesisPareja(it,e)=FALSE B A si e=NULL O sonParentesisPareja(it,e)=FALSE B
devolver FALSE devolver FALSE
si pila_vacia(p) = FALSE C si pila_vacia(p) = FALSE C

devolver FALSE devolver FALSE
devolver TRUE devolver TRUE
} }
Posibles fuentes de error (funciones que pueden devolver ERROR): 1 2
Errores de balanceo se detectan en: A B C Errores de balanceo se detectan en: A B C

Contenidos 39
• Pseudocódigo (sin CdE)

• El TAD Pila
p = pila_crear()
si esSimboloApertura(it) // si es (, [ o { • Implementación en C de Pila
pila_push(p,it)
si no, si esSimboloCierre(it) • Implementación con top de tipo entero
e = pila_pop(p)
si e=NULL O sonParentesisPareja(it,e)=FALSE • Ejemplos de aplicación de Pila
pila_liberar(p)
devolver FALSE • Balanceo de paréntesis
si pila_vacia(p) = FALSE • Evaluación de expresiones posfijo
pila_liberar(p)
devolver FALSE • Conversión entre notaciones infijo, posfijo y prefijo
pila_liberar(p)
devolver TRUE
} • Anexo
• Ejemplo 4: { 3 * 4 / ( 6 - 1 ) } • Implementación con top de tipo puntero
• Ejemplo 5: 2 + ( 5 / [ 4 + 7 ) )
Evaluación de expresiones posfijo 40
• Ejemplos
• Notación infijo • Ejemplo: 2 3 + 3 1 + + ;
• Los operadores se indican entre operandos: A+B
• La habitual 1
• Notación posfijo (o sufijo) 2

3
2 5
3
5
3
5
4
5 9
• Los operadores se indican después de los operandos: AB+
• La más “práctica” para un ordenador • Ejemplo: 1 2 * 4 2 / 3 4 + 5 * - + ;
• Notación prefijo
• Los operadores se indican antes de los operandos: +AB
• Ejemplo:
• En infijo: 2 - 3 * (4 + 1)
• En posfijo: 2 3 4 1 + * -
• En prefijo: - 2 * 3 + 4 1

• Ejemplos • Pseudocódigo (sin CdE)

6 2 / 3 2 * 5 1 - 3 * + - ; status evaluarPosfijo(CC S, Entero r) {
p = pila_crear()
si esOperando(it)
pila_push(p,it)
else si esOperador(it)
op2 = pila_pop(p)
op1 = pila_pop(p)
e = evaluar(op1,op2,it)
pila_push(p,e)
r = pila_pop(p)
A B * C - ; si pila_vacia(p)=FALSE // si la pila no queda vacía, incorrecto
pila_liberar(p)
devolver ERROR
// Si queda vacía, correcto; en r está el resultado (el ultimo pop)

pila_liberar(p)
devolver OK
} • Ejemplo: 1 6 * 2 1 / 3 4 - + ;
• 2 3 + 3 1 + + ; 9
• 1 2 * 4 2 / 3 4 + 5 * - + ; - 31
• Pseudocódigo (con CdE) • Pseudocódigo (con CdE)

status evaluarPosfijo(CC S, Entero r) { status evaluarPosfijo(CC S, Entero r) {
si (p=pila_crear())=NULL devolver ERROR si (p=pila_crear())=NULL devolver ERROR
mientras (it = leerItem(S)) ≠ FIN: mientras (it = leerItem(S)) ≠ FIN:
si esOperando(it) si esOperando(it)
si pila_push(p,it = ERROR) // ERROR 1: la pila está llena si pila_push(p,it = ERROR) // ERROR 1: la pila está llena
devolver ERROR devolver ERROR • Ejemplo: 1 6 * 2 + / ;
si no, si esOperador(it) si no, si esOperador(it)
op2 = pila_pop(p) op2 = pila_pop(p) • Ejemplo: 1 6 * 2 1 / 3 4 - + ;
op1 = pila_pop(p) op1 = pila_pop(p)
si (op2 ≠ ERROR) Y (op1 ≠ ERROR) si (op2 ≠ ERROR) Y (op1 ≠ ERROR)
e = evaluar(op1,op2,it) e = evaluar(op1,op2,it)
pila_push(p,e) //Como se extraen 2, se assume que cabe 1 pila_push(p,e) //Como se extraen 2, se assume que cabe 1
si no // ERROR 2: no hay suficientes operandos en la pila si no // ERROR 2: no hay suficientes operandos en la pila
devolver ERROR devolver ERROR
r = pila_pop(p) r = pila_pop(p)
si r=NULL //ERROR 3: imposible extraer resultado si r=NULL //ERROR 3: imposible extraer resultado
si (pila_vacia(p)=FALSE) //ERROR 4: la pila al final no queda vacía si (pila_vacia(p)=FALSE) //ERROR 4: la pila al final no queda vacía
} }

Contenidos 46
Conversión de expresiones: infijo-posfijo 47
• Infijo Posfijo
• El TAD Pila
• Conversión de A + B * C
• Estructura de datos y primitivas de Pila • A +(B * C)=> AB+C*
• Implementación en C de Pila • A + B * C => ABC*+
• Implementación con top de tipo entero • Hay que tener en cuenta:

• Precedencia de operadores
• Asociatividad de operaciones (a igual precedencia, de izquierda a derecha)
• Balanceo de paréntesis precedencia
• Evaluación de expresiones posfijo + operador asociatividad

() [] . -> izquierda-derecha
• Conversión entre notaciones infijo, posfijo y prefijo * / %
+ -
izquierda-derecha
• Anexo &&
||
• Implementación con top de tipo puntero = derecha-izquierda
-
• Idea inicial
A + B * C ; => ABC*+
• Otro ejemplo
Símbolo Traducción parcial Pila de OPERADORES A * B + C / E ; => AB*CE/+
A A Símbolo Traducción parcial Pila de OPERADORES
+ A + A A
B AB + * A *
* AB + * B AB *
C ABC + * + AB * +
; ABC*+ C ABC * +
/ ABC * + /
• Posible algoritmo E ABCE * + /
; ABCE/+* MAL
1. Si el símbolo actual it es operando: “imprimir”
(añadir it a cadena de traducción parcial)
• Ajustes al algoritmo
2. Si it es operador: pila_push(pila, it)
• Los operadores de mayor precedencia salen antes de pila
3. Al final: vaciar pila e imprimiendo elementos en cadena
• A igual precedencia, sale antes el que se leyó antes
traducción en el orden en que se van extrayendo

• Algoritmo
• Teniendo en cuenta precedencia de operadores 1. Si it es operando, añadir a la expresión
A * B + C / E ; => AB*CE/+
2. Si es operador:
Símbolo Traducción parcial Pila de OPERADORES
A A
mientras prec (operador) ≤ prec (tope(pila))
* A * extraer elemento de la pila y añadir a la expresión
B AB * meter operador leído en la pila
+ AB* +
C AB*C +
3. Si es fin de cadena:
/ AB*C + / mientras pila no vacía:
E AB*CE + / extraer elemento de la pila y añadirlo a la expresión
; AB*CE/+
• Idea para el algoritmo • Teniendo en cuenta precedencia de operadores

A + B * C – D ; => ABC*+D-
1. Si it es operando, imprimir it
Símbolo Traducción parcial Pila de OPERADORES
2. Un operador leído saca de la pila operadores de mayor o igual precedencia A A
+ A +
>: el más preferente sale antes
B AB +
=: por la regla de asociatividad izquierda-derecha, también sale antes * AB + *
3. Al final, vaciar la pila de operandos e imprimir C ABC + *
- ABC*+ -
Programación II – Tema 2: Pilas D ABC*+D
Programación II – Tema 2: Pilas -
Universidad Autónoma de Madrid ; ABC*+D-

status infijoAPosfijo(CC S1, CC S2) status infijoAPosfijo(CC S1, CC S2)
mientras (it=leerItem(S1)) ≠ FIN: mientras (it=leerItem(S1)) ≠ FIN:
si esOperando(it)=TRUE si esOperando(it)=TRUE
print(S2,it) print(S2,it)
si no, si esOperador(it)=TRUE si no, si esOperador(it)=TRUE
mientras (pila_vacia(p)=FALSE) Y (prec(it)≤ prec(top(p)) mientras (pila_vacia(p)=FALSE) Y (prec(it)≤ prec(top(p))
print(S2,e) print(S2,e)
pila_push(p,it) 2 pila_push(p,it)
mientras pila_vacia(p)=FALSE: mientras pila_vacia(p)=FALSE:
it = pila_pop(p) it = pila_pop(p)
print(S2,it) print(S2,it)
pila_liberar(p) prec(op): Devuelve el nivel de precedencia de un operador
pila_liberar(p)
devolver OK top(p): Devuelve el valor en el top de la pila, sin extraerlo devolver OK
print(S,it): Concatena el carácter it al final de la cadena S
• ¿CdE?
Línea 1 cambia a: Línea 2 cambia a:
• pila_crear: comprobarlo
• pila_pop: no hay que controlar error, porque justo antes se mira si está vacía. si (p=pila_crear())=ERROR si pila_push(p,it)=ERROR
• pila_push: si pila llena, error devolver ERROR devolver ERROR
• operadores correctos: leerItem, esOperando, esOperador

• Con paréntesis…
• ¡Ojo! A diferencia de la evaluación, el algoritmo de A * B / (C + D) * (E – F);
conversión no detecta errores sintácticos
• Clave: tratar las expresiones entre paréntesis como
• A+B* AB*+
expresiones en si misma se traducen antes de seguir la
• ABC* ABC*
traducción general
• Función de precedencia • Ejemplo: A * B / [CD+] * [EF-] => AB*CD+/EF-*
int prec(char op)
switch(op) {
• En la práctica:
case '+': case '-': return 1; • ‘(‘ se introduce en la pila
case '*': case '/': return 2;
case '^': return 3; • cuando se encuentra ‘)’ se sacan todos los operadores hasta ‘(‘
}
return 0; // Error • ¿Hay que tener en cuenta el balanceado de paréntesis?
} • El algoritmo de conversión lo tendrá en cuenta
• Con paréntesis… • Con paréntesis…

A * B / (C + D) * (E – F) ; A * B / (C + D) * (E – F) ;
Símbolo Traducción parcial Pila de OPERADORES Símbolo Traducción parcial Pila de OPERADORES
• Clave: tratar las expresiones entre paréntesis como • Clave: tratar lasA expresiones
A entre paréntesis como
* A *
expresiones en si misma se traducen antes de seguir la expresiones enBsi misma AB se traducen
* antes de seguir la
/ AB* /
traducción general traducción general
( AB* /(
• Ejemplo: A * B / [CD+] * [EF-] => AB*[CD+]/[EF-]* • Ejemplo: A * C+B / [CD+]

AB*C
AB*C
/(
* [EF-] =>
/(+
AB*[CD+]/[EF-]*
• En la práctica: • En la práctica: D
)
AB*CD
AB*CD+
/(+
/
• ‘(‘ se introduce en la pila • ‘(‘ se introduce en la pila
* AB*CD+/ *
( AB*CD+/ *(
• cuando se encuentra ‘)’ se sacan todos los operadores hasta ‘(‘ • cuando se encuentra ‘)’ se sacan todos los operadores hasta ‘(‘
E AB*CD+/E *(
- AB*CD+/E *(-
• ¿Hay que tener en cuenta el balanceado de paréntesis? • ¿Hay que tener en cuenta el balanceado de paréntesis?
F AB*CD+/EF *(-
) AB*CD+/EF- *
• El algoritmo de conversión lo tendrá en cuenta • El algoritmo de conversión lo tendrá en cuenta
; AB*CD+/EF-*

Conversión de expresiones: posfijo-prefijo 58

Conversión de expresiones: posfijo-infijo 59
• Se puede seguir la misma estrategia de evaluación para • Posfijo Infijo

otras conversiones 1) Algoritmo de evaluación de expresiones posfijo
• Posfijo Prefijo 2) En vez de “operar”, crear expresiones parciales de tipo infijo
1) Algoritmo de evaluación de expresiones posfijo e introducirlas, entre paréntesis, en la pila
2) En vez de “operar”, crear expresiones parciales de tipo prefijo • Ejemplo: AB/CD+/EF-*
(e introducirlas en la pila, como se hacía al evaluar con el
resultado)
• Ejemplo: AB*CD+/

Conversión de expresiones: infijo-prefijo 60
Repaso 61
• Infijo
prefijo • Evaluar la siguiente expresión sufijo
2 1 / 4 2 * + 6 5 – 8 2 / + + ;
Algoritmo: infijo sufijo prefijo
• Convertir la siguiente expresión infijo en sufijo
A + B / C – D * F ;
• Ejemplos:
• Convertir la siguiente expresión infijo en sufijo
A+B–C; (A+B)*(C-D); (A + B) / C * (D – E) + F ;
• Convertir la siguiente expresión sufijo en infijo
A B C / + D F * - ;
• Convertir la siguiente expresión sufijo en prefijo
A B C / + D F * - ;
• Evaluar la siguiente expresión prefijo
/ / 6 5 – 9 3 ;

Contenidos 62
• El TAD Pila
• Estructura de datos y primitivas de Pila • Implementación con top de tipo puntero
• Asumimos la existencia del TAD Elemento
• Implementación en C de Pila 7
• EdD de Pila mediante un array
// En pila.h x
5
• Ejemplos de aplicación de Pila typedef struct _Pila Pila;
4 x
• Balanceo de paréntesis // En pila.c 3
#define PILA_MAX 8 x
• Evaluación de expresiones posfijo struct _Pila { 2
x
Elemento *datos[PILA_MAX];
• Conversión entre notaciones infijo, posfijo y prefijo 1
Elemento **top; x
0
};
• Anexo top datos

• Implementación con top de tipo puntero • Implementación con top de tipo puntero
• Asumimos la existencia del TAD Elemento que, entre otras, • Asumimos la existencia del TAD Elemento que, entre otras,
tiene asociadas las primitivas liberar y copiar: tiene asociadas las primitivas liberar y copiar:
void elemento_liberar(Elemento *pe); void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe); Elemento *elemento_copiar(const Elemento *pe);
• Primitivas (prototipos en pila.h) • Primitivas (prototipos en pila.h)

7 7
Pila *pila_crear(); Pila *pila_crear();
void pila_liberar(Pila *ps); 6 void pila_liberar(Pila *ps); 6
boolean pila_vacia(const Pila *ps); x boolean pila_vacia(const Pila *ps); x
5 5
boolean pila_llena(const Pila *ps); boolean pila_llena(const Pila *ps);
status pila_push(Pila *ps, const Elemento *pe); 4 x status pila_push(Pila *ps, const Elemento *pe); 4 x
Elemento *pila_pop(Pila *ps); Elemento *pila_pop(Pila *ps);
3 x 3 x
• Estructura de datos (en pila.c) 2 • Estructura de datos (en pila.c) 2
x x
struct _Pila { 1 struct _Pila { 1
Elemento *datos[PILA_MAX]; 0
x Elemento *datos[PILA_MAX]; 0
x
Elemento **top; Elemento **top;
}; top datos }; top datos

Existe: void elemento_liberar(Elemento *pe);
Pila *pila_crear() {
vacía 7
Pila *ps = NULL;
void pila_liberar(Pila *ps) { 6
int i; 7
6 if (ps != NULL) { 5
ps = (Pila *) malloc(sizeof(Pila));
while (ps->top >= ps->datos) {
if (ps == NULL) { 5 4 x
elemento_liberar(ps->top);
return NULL;
ps->top--; 3
} 4 x
}
3 2
free(ps);
for (int i=0; i<PILA_MAX; i++) { // Bucle opcional x
// ps = NULL; se hace fuera, 1
ps->datos[i] = NULL; 2 // tras llamar a pila_liberar
} } 0 x
1
}
ps->top = NULL; 0 top datos x
return ps; top datos

}
ps
ps
Existe: void elemento_liberar(Elemento *pe); Existe: void elemento_liberar(Elemento *pe);
7 7
void pila_liberar(Pila *ps) { 6 void pila_liberar(Pila *ps) { 6
if (ps != NULL) { 5 if (ps != NULL) { 5

while (ps->top >= ps->datos) { while (ps->top >= ps->datos) {
4 x 4
elemento_liberar(ps->top); elemento_liberar(ps->top);
ps->top--; 3 ps->top--; 3
x
} }
2 2
free(ps); free(ps);
x
// ps = NULL; se hace fuera, 1 // ps = NULL; se hace fuera, 1
// tras llamar a pila_liberar // tras llamar a pila_liberar
} 0 x } 0
} }
top datos x top datos
ps
ps

• Asumimos la existencia del TAD Elemento que, entre otras,
tiene asociadas las primitivas liberar y copiar: vacía
void elemento_liberar(Elemento *pe);
Elemento *elemento_copiar(const Elemento *pe); boolean pila_vacia(const Pila *ps) { 7
if (ps == NULL) {
6
• Primitivas (prototipos en pila.h) return TRUE;
7 } 5
Pila *pila_crear();
void pila_liberar(Pila *ps); 6 4
boolean pila_vacia(const Pila *ps); x if (ps->top == NULL) {
5 return TRUE; 3
boolean pila_llena(const Pila *ps);
x }
status pila_push(Pila *ps, const Elemento *pe); 4 2
return FALSE;
Elemento *pila_pop(Pila *ps); }
3 x 1
• Estructura de datos (en pila.c) 2 0
x
struct _Pila { 1 top datos
Elemento *datos[PILA_MAX]; x
0
Elemento **top;
}; top datos
ps
• Asumimos la existencia del TAD Elemento que, entre otras,
llena x
tiene asociadas las primitivas liberar y copiar:
void elemento_liberar(Elemento *pe);
boolean pila_llena(const Pila *ps) {
7 Elemento *elemento_copiar(const Elemento *pe);
if (ps == NULL) { x
return TRUE; 6
} x • Primitivas (prototipos en pila.h)
5 7
Pila *pila_crear();
// if (ps->top == ps->datos + PILA_MAX - 1) 4 x void pila_liberar(Pila *ps); 6
if (ps->top == &(ps->datos[PILA_MAX-1])) { boolean pila_vacia(const Pila *ps); x
3 5
return TRUE; x boolean pila_llena(const Pila *ps);
} 2 status pila_push(Pila *ps, const Elemento *pe); 4 x
return FALSE; x Elemento *pila_pop(Pila *ps);
3
} 1 x
0 x • Estructura de datos (en pila.c) 2
x
struct _Pila { 1
top datos x Elemento *datos[PILA_MAX]; x
0
Elemento **top;
}; top datos
ps
status pila_push(Pila *ps, const Elemento *pe){ status pila_push(Pila *ps, const Elemento *pe){
Elemento *aux = NULL; Elemento *aux = NULL;
if (ps == NULL || pe == NULL || pila_llena(ps) == TRUE) { if (ps == NULL || pe == NULL || pila_llena(ps) == TRUE) {
return ERR; aux return ERR; aux
} }
7 push 7 7 push 7
aux = elemento_copiar(pe); aux = elemento_copiar(pe);
if (aux == NULL) { 6 6 if (aux == NULL) { 6 6
return ERR; return ERR;
5 5 e 5 5 e
} }
4 x 4 x // Actualizamos el top
4 x 4 x
if (ps->top == NULL) { 3 3 if (ps->top == NULL) { 3 3
// ps->top = ps->datos x x // ps->top = ps->datos x x
ps->top = &(ps->datos[0]); 2 2 ps->top = &(ps->datos[0]); 2 2
} x x } x x
else { 1 1 else { 1 1
ps->top++;
0 x 0 x ps->top++;
0 x 0 x
} }
e top datos x e top datos x e top datos x e top datos x
// Guardamos el dato en el top // Guardamos el
*(ps->top) = aux; // dato en el top
*(ps->top) = aux;
return OK; Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas
} Escuela Politécnica Superior return OK; Escuela Politécnica Superior
pe ps Autónoma de Madrid
Universidad pe ps }
pe ps Autónoma de Madrid
Universidad pe ps
Elemento *pila_pop(const Pila *ps){
• Asumimos la existencia del TAD Elemento que, entre otras, Elemento *pe = NULL; pe
tiene asociadas las primitivas liberar y copiar: if (ps == NULL || pila_vacia(ps) == TRUE) {
void elemento_liberar(Elemento *pe); return NULL;
Elemento *elemento_copiar(const Elemento *pe); } 7 pop 7
• Primitivas (prototipos en pila.h) // Recuperamos el dato del top 6 6

7 pe = *(ps->top);
Pila *pila_crear(); 5 5
void pila_liberar(Pila *ps); 6
boolean pila_vacia(const Pila *ps); x // Ponemos el Elemento* a NULL 4 e 4 e
5 *(ps->top) = NULL;
boolean pila_llena(const Pila *ps); 3 3
x x x
status pila_push(Pila *ps, const Elemento *pe); 4 // Actualizamos el top 2 2
Elemento *pila_pop(Pila *ps); // if (ps->top != ps->datos) x x
3 x if (ps->top != &ps->datos[0]) { 1 1
• Estructura de datos (en pila.c) 2 ps->top--;
x x
x 0 0
}
struct _Pila { 1 else { top datos top datos
Elemento *datos[PILA_MAX]; x x
0
x ps->top = NULL;
Elemento **top; }
}; top datos return pe;
} ps ps

Elemento *pila_pop(const Pila *ps){
if (ps == NULL || pila_vacia(ps) == TRUE) {

return NULL;
} 7 pop 7
6 6
pe = *(ps->top); 5
5
// Ponemos el Elemento* a NULL 4 e 4 e

*(ps->top) = NULL;
3 3
x x
// Actualizamos el top 2 2
// if (ps->top != ps->datos) x x
if (ps->top != &ps->datos[0]) { 1 1
ps->top--; x
0 x 0
}
else { top datos top datos
x x
ps->top = NULL;
}
return pe;
} ps ps
Programación II – Tema 2: Pilas
Escuela Politécnica Superior

7 Prog2 Tema2 Pilas

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

7 Prog2 Tema2 Pilas

Încărcat de

Drepturi de autor:

Formate disponibile

Contenidos 1

Iván Cantador y Rosa Mª Carro • Anexo

• Pila (stack en inglés)

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

• Definición de Pila • Aplicaciones reales de las pilas

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

• Una pila está formada por:

• Ejemplos de aplicación de Pila 6

4 x (en este dibujo asumimos que la pila

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

status pila_push(Pila s, Elemento e): inserta un dato en una pila 4 x 4 x

top datos top datos

• Anexo top datos

• Implementación con top de tipo puntero

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

• Primitivas (prototipos en pila.h) • Primitivas (prototipos en pila.h)

void pila_liberar(Pila *ps); 6 void pila_liberar(Pila *ps); 6

}; top datos }; top datos

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

void pila_liberar(Pila *ps) { 6 void pila_liberar(Pila *ps) { 6

if (ps != NULL) { 4 x if (ps != NULL) { 4

top datos x top datos

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

aux = elemento_copiar(pe); 7 push 7

// Actualizamos el top 4 x 4 x // Actualizamos el top 4 x 4 x

e top datos x e top datos x e top datos x e top datos x

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

• Primitivas (prototipos en pila.h) 6 6

• Estructura de datos (en pila.c) 2

• Implementación con top de tipo entero

• Pseudocódigo (sin CdE)

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

• Pseudocódigo (sin CdE) • Pseudocódigo (sin CdE)

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

• Pseudocódigo incompleto (solo mira paréntesis, sin CdE)

mientras (it=leerSimbolo(S)) ≠ FIN: // leer siguiente símbolo de S

aritmética) contiene el mismo número de paréntesis de si no, si esParentesisCierre(it) // si it = ‘)‘

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

• Pseudocódigo (sin CdE) • Pseudocódigo (sin CdE)

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

• Pseudocódigo (sin CdE) • Pseudocódigo (sin CdE)

si pila_vacia(p) = FALSE C si pila_vacia(p) = FALSE C

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

• Pseudocódigo (sin CdE)

• Notación posfijo (o sufijo) 2

Evaluación de expresiones posfijo 42

• Ejemplos • Pseudocódigo (sin CdE)

// Si queda vacía, correcto; en r está el resultado (el ultimo pop)

• Pseudocódigo (con CdE) • Pseudocódigo (con CdE)

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

• Implementación con top de tipo entero • Hay que tener en cuenta:

• Evaluación de expresiones posfijo + operador asociatividad

Conversión de expresiones: infijo-posfijo 50

• Idea para el algoritmo • Teniendo en cuenta precedencia de operadores

• Pseudocódigo (sin CdE) • Pseudocódigo (sin CdE)

Conversión de expresiones: infijo-posfijo 54

• Con paréntesis… • Con paréntesis…

• Ejemplo: A * B / [CD+] * [EF-] => AB*[CD+]/[EF-]* • Ejemplo: A * C+B / [CD+]

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

Conversión de expresiones: posfijo-prefijo 58

• Se puede seguir la misma estrategia de evaluación para • Posfijo Infijo

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

Programación II – Tema 2: Pilas Programación II – Tema 2: Pilas

void pila_liberar(Pila ps); 6 void pila_liberar(Pila ps); 6

void pila_liberar(Pila ps) { 6 void pila_liberar(Pila ps) { 6

• Ejemplo: A * B / [CD+] * [EF-] => AB[CD+]/[EF-] • Ejemplo: A * C+B / [CD+]