1. REPÚBLICA BOLIVARIANA DE VENEZUELA
UNIVERSIDAD FERMÍN TORO
VICERECTORADO ACADÉMICO
DECANATO DE INGENIERIA
ESCUELA DE COMPUTACIÓN
SEDE CABUDARE
Shearly Achji
Ricardo Ros
Estructuras de Datos I
Saia

2. EJERCICIOS EVALUADOS I
Esta es una de las aplicaciones más sencillas que podamos implementar usando pilas.
Balancear paréntesis consiste en que dada una expresión aritmética en el que se usen
paréntesis como signos de agrupación, se debe determinar si los paréntesis que abren
están en concordancia con lo que cierran. Si esto es así, entonces se dice que los
paréntesis están balanceados.
SOLUCIÓN: La solución consiste en mantener una pila en la que se vayan insertando uno
a uno los paréntesis que abren ’(’, leyendo la expresión (considerándola como una
cadena) de izquierda a derecha. Cada vez que se encuentra un paréntesis que cierra ’)’ se
debe verificar que al frente de la pila haya uno que abra, si es así entonces sacar de la pila
ese paréntesis. En este proceso pueden suceder los siguientes casos:
1 - CASO CORRECTO: Si la expresión se leyó completamente y la pila quedo vacía
entonces la expresión tiene los paréntesis balanceados.
2 - CASOS INCORRECTOS:
 Si la expresión se leyó completamente, pero la pila no quedó vacía. Esto indica
que faltan paréntesis por cerrar, por lo tanto la expresión no tiene los paréntesis
balanceados.

3.  Si se leyó un paréntesis que cierra pero la pila está vacía. Esto indica que hay un
inesperado paréntesis que cierra, al no haber el correspondiente paréntesis que lo
abre. En este caso también los paréntesis no están balanceados.
2.4.2
Este problema es similar al problema anterior pero ahora puede usar tres tipos de
operadores de agrupación: las llaves ({, }), los corchetes ([, ]) y los paréntesis ((,)).
En este caso, los operadores de apertura irán a la pila, y cuando encontremos un operador
que cierra debemos verificar si en el frente de la pila está su correspondiente operador
que abre. Si es así, aplicamos pop en la pila, de otro modo se trata de un error. La
expresión será correcta si al finalizar de procesar toda la expresión de entrada la pila
quedo vacía.
Igual que en el caso anterior, usaremos una pila de caracteres.
Sabemos que se leyó un símbolo de agrupación que cierra pero la pila está vacía. Cuando
hay un inesperado símbolo de agrupación que cierra, al no haber el correspondiente
símbolo de agrupación que lo abre.
3. Convertir las siguientes expresiones en su representación
postfija:

4. 1. A+B
AB+
2. A+B-C
AB+C-
3. (A+B) * (C-D)
AB+*CD-
AB+CD-*
4. A$B*C–D+E/F/(G+H)
AB$*C-D+E/F/GH+
AB$C*-D+E/F/GH+
AB$C*-D+EF//GH+
AB$C*-D+EF/GH+/
AB$C*D-+EF/GH+/
AB$C*D-EF/GH+/+
5. ((A+B)*C–(D-E))$(F+G)

5. (AB+*C-DE-)$(F+G)
(AB+C*-DE-)$(FG)
AB+C*DE--$FG+
AB+C*DE- -FG+$
6. A–B/(C*D$E)
A-B/(C*DE$)
A-B/CDE$*
A-BCDE$*/
ABCDE$*/-

6. 4. Implemente el operador de la clase stack peek() que retorna el elemento
del tope del Stack SIN eliminarlo.
Código en JAVA:
package pilas;
import java.util.Stack;
public class Pilas {
public static void main(String[] args) {
Stack < String > pila = new Stack < String > ();
//apila 3 elementos
pila.push("elemento1");
pila.push("elemento2");
pila.push("elemento3");
System.out.println("1- push: " + pila);
//retira elemento que está en la cima de la pila
pila.pop();
System.out.println("2- pop: " + pila);
//devuelve el elemento que está en la cima de la pila
String x = pila.peek();
System.out.println("3- peek: " + x);
//devuelve cierto si la pila esta vacia
boolean y = pila.empty();
System.out.println("4- empty: " + y);
}
}
Obteniendo como resultado:
1- push: [elemento1, elemento2, elemento3]
2- pop: [elemento1, elemento2]
3- peek: elemento2
4- empty: false
BUILD SUCCESSFUL (total time: 0 seconds)

7. 5. Implemente el operador de la clase stack reset() que elimina todos los
elementos del Stack dejando la pila vacía.
Código en C++:
include <iostream.h>
#include <conio.h>
const int TPILA=9; // TPILA es el valor máximo de elementos
// Que puede tener nuestra pila
class PILA{
public:
int mipila[TPILA]; // Crea PILA de tamano TPILA
int apilados; // Numero de objetos en LA PILA
void reset(); // Vacia LA PILA
void push(int v); // Agrega Valores en el tope de la PILA
int pop(); // Retorna y elimina el tope de la PILA
};
void PILA::reset() // Vacia la PILA
{
apilados=0;
}
//Se Agrega(PUSH) un valor en el tope de la pila
void PILA::push(int v)
{
// Comprueba que haya espacio dentro de la pila
// para poder agregar el nuevo valor
if(apilados<TPILA)
{
mipila[apilados++]=v;
}
}
// Se Elimina (POP) el ultimo valor de la pila
// y retorna el nuevo tope
int PILA::pop()
{
if(apilados>0)
{
cout<<"El valor del tope eliminado era: ";
// Retorna el valor del tope que fue eliminado
return(mipila[--apilados]);

8. }
else
cout<<"No hay personas. ERROR ";
return (0);
}
main()
{
PILA stack;
stack.reset();
int opc, i, dato;
char out;
do
{
do
{
clrscr();
cout<<"Que operacion desea Realizarnn";
cout<<"1.- Insertar un daton";
cout<<"2.- Borrar un daton";
cout<<"3.- Mostrar pilan";
cout<<"4.- Resetear Pilan";
cout<<"5.- Salir";
cout<<"nnnOpcion(1-5): ";
cin>>opc;
}
while(opc>5);
switch(opc)
{
case(1):
if(stack.apilados<TPILA)
{
cout<<"dato?: ";
cin>>dato;
stack.push(dato);
}
else
cout<<"ERROR! PILA LLENA!";
cout<<"nnsalir?? (S/N): "; cin>>out;
break;
case(2):
cout<<stack.pop()<<endl;
cout<<"nnSalir?? (S/N): "; cin>>out;
break;
case(3):

9. if(stack.apilados!=0)
{
cout<<"Las personas en la Fila actualmente son: "<<endl;
for(i=0;i<stack.apilados;i++)
{ cout<<stack.mipila[i]<<endl; }
}
else
cout<<"No hay personas en la Fila"<<endl;
cout<<"nnSalir?? (S/N): "; cin>>out;
break;
case(4):
stack.reset();
cout<<"nnSalir?? (S/N): "; cin>>out;
break;
case(5):
out='s'; break;
default:
out='s'; break;
}
}
while(out=='n' || out=='N');
}