REPÚBLICA BOLIVARIANA DE VENEZUELA

UNIVERSIDAD RÓMULO GALLEGOS

AREA DE INGENIERIA DE SISTEMAS
ESCUELA DE INGENIERÍA EN INFORMÁTICA
ESTRUCTURAS DISCRETAS II
PROF. ARGENIS MENDOZA

GUIA DE EJERCICIOS
PILAS

pilagenerica.h

/**************************Pila Genérica*********************************/
template <class T>
class PilaGenerica{

class NodoPila{
public:
NodoPila *siguiente;
T elemento;
NodoPila(T x){
elemento = x;
siguiente = NULL;
}
};

NodoPila *cima;
public:
//Constructor de la clase pilagenerica
PilaGenerica(){
cima = NULL;
}
//Método para añadir elementos a la pila
void meter(T elemento);
//Método para sacar elementos de la pila
T sacar(); const
//Método para consultar el elemento en la cima de pila
T cimaPila(); const
bool pilaVacia();
void limpiarPila();
~PilaGenerica(){
limpiarPila();
}
};
//Implementación Métodos
//Método para la Verificación del estado de la pila

template <class T>

const bool PilaGenerica<T>::pilaVacia()
{
return cima == NULL;
}
//Método para poner un elemento en la pila
template <class T>
void PilaGenerica<T>::meter(T elemento){
NodoPila *nuevo;
nuevo = new NodoPila(elemento);
nuevo->siguiente = cima;
cima = nuevo;
}

//Método para sacar un elemento de la pila

template <class T>
T PilaGenerica<T>::sacar(){
if(pilaVacia()){
throw "Pila vacía, no se puede extraer elementos!";
}
T aux = cima->elemento;
cima = cima->siguiente;
return aux;
}

//Método para la obtención del elemento cima de la pila

template <class T>
const T PilaGenerica<T>::cimaPila(){
if(pilaVacia())
throw "Pila Vacía";
return cima->elemento;
}

//Método para el vaciado de la pila

template <class T>
void PilaGenerica<T>::limpiarPila(){
NodoPila *n;
while(!pilaVacia()){
n = cima;
cima = cima->siguiente;
delete n;
}
}

programa.cpp

#include<iostream>
#include"pilagenerica.h"
using namespace std;

int main(){
PilaGenerica<int> p, p2;
int i, num;
for(i=0;i<4;i++){
cout << "Ingrese un numero entero: ";
 cin >> num;
p.meter(num);
}
while(!p.pilaVacia()){
num = p.sacar();
cout << num << endl;
p2.meter(num);
}
while(!p2.pilaVacia()){
p.meter(p2.sacar());
}
cout << "ELIMINAR UN DATO DE LA PILA" << endl;
cout << "Ingrese el numero: ";
cin >> num;
int aux;
bool b=false;
while(!p.pilaVacia()){
aux= p.sacar();
if(aux!=num){
p2.meter(aux);
}
else{
b=true;
}
}
if(b){
cout << "Dato eliminado!" << endl;
}
else{
cout << "Dato no pudo eliminarse. No esta en la pila!" << endl;
}
while(!p2.pilaVacia()){
p.meter(p2.sacar());
}

cout << "PILA RESULTANTE: " << endl;

while(!p.pilaVacia()){
cout << p.sacar() << endl;
}
return 0;
}

programa2.cpp

#include<iostream>
#include"pilagenerica.h"
using namespace std;

struct Estudiante{
int cedula;
string apellido;
 string nombre;
float nota;
};
int main(){
PilaGenerica<Estudiante> pila;
Estudiante reg;
char r;
int c=0;
float nt=0;
cout << "CARGA DE DATOS EN LA PILA" << endl;
do{
cout << "DATOS DEL ESTUDIANTE" << endl;
cout << "Cedula: ";
cin >> reg.cedula;
cout << "Apellido: ";
cin >> reg.apellido;
cout << "Nombre: ";
cin>> reg.nombre;
cout << "Nota: ";
cin >> reg.nota;
pila.meter(reg);
c++;
cout << "Desea ingresar otro estudiante(s/n): ";
cin >> r;
}while(toupper(r)=='S');
while(!pila.pilaVacia()){
reg = pila.sacar();
cout << reg.cedula << " " << reg.apellido << " " << reg.nombre << " " << reg.nota
<< endl;
}
cout << "Total registros: " << c << endl;

#include<iostream>
#include "pilagenerica.h"
using namespace std;

struct Persona{
char cedula[12];
string nombre;
string apellido;
int edad;
};

int main(){
struct Persona p,aux, mayor;
mayor.edad = 0;
PilaGenerica<Persona> pila, pila2;
for (int i = 0; i<2; i++){
cout << "DATOS PERSONA" << endl;
cout << "Cedula: ";
 cin >> p.cedula;
cout << "Nombre: ";
cin >> p.nombre;
cout << "Apellido: ";
cin >> p.apellido;
cout << "Edad: ";
cin >> p.edad;
pila.meter(p);
}
cout <<"DATOS ALMACENADOS EN LA PILA" << endl;
while(!pila.pilaVacia()){
aux = pila.sacar();
if(aux.edad>mayor.edad){
mayor = aux;
}
cout << aux.cedula << " " << aux.apellido << ", " << aux.nombre << endl;
pila2.meter(aux);
}

cout << "Persona con mayor edad es: " << mayor.nombre << ", " << mayor. apellido << endl;
while(!pila2.pilaVacia()){
pila.meter(pila2.sacar());

programa4.cpp

#include<iostream>
#include "cpila.h"
using namespace std;

int main(){
PilaGenerica<int> p1, p2;
int c1 = 0, c2 = 0, acum1 = 0, acum2 = 0, dato;
float prom = 0;
char r = 'S';
cout << "CARGA DE DATOS EN LAS PILAS" << endl;
do{
cout << "Ingrese numero: ";
cin >> dato;
if(dato%2==0){
p1.meter(dato);
c1++;
acum1+=dato;
}
else{
p2.meter(dato);
c2++;
acum2 = acum2 + dato;
 }
cout << "Desea ingresar otro dato(s/n): ";
cin >> r;
}while(r=='s' || r=='S');
cout << "RESULTADOS:" << endl;
cout <<"Pila Uno:" << endl;
while(!p1.vacia()){
cout << p1.sacar() << endl;
}
cout << "Total de datos cargados en la pila uno es: " << c1 << endl;
cout << "Pila Dos: " << endl;
while(!p2.vacia()){
cout << p2.sacar() << endl;
}
cout << "Total de datos cargados en la pila dos es: " << c2 << endl;
if(c1>c2){
cout <<"Pila uno contiene mas datos que la Pila dos" << endl;
}
else{
if(c2>c1){
cout << "Pila dos contiene mas datos que la Pila Uno: " << endl;
}
else{
cout << "Pila Uno y Pila dos contiene la misma cantidad de datos" << endl;
}
}
prom = (float)(acum1+acum2)/(c1+c2);
cout << "El promedio de los datos cargados en la pilas es: " << prom << endl;
return 0;
}

Ejercicios Propuestos

1. Desarrollar la implementación dinámica del TDA pila. Las operaciones básicas a considerar
son: crearpila, meter, sacar, cimapila, pilavacia.

2. Diseñar un programa que permita cargar Nº cantidad de datos de tipo real en una pila. Al
finalizar la carga de los datos. El programa debe mostrar lo siguiente: a) el total datos
cargados en la pila, b) el total datos negativos, c) el total datos positivos, d) el mayor de los
datos cargados, e) el menor de los datos cargados. Luego de realizar las operaciones con los
datos, la pila debe mantener los valores cargados al final del programa. Puede utilizarse una
pila, una cola o una lista enlazada como estructura auxiliar.

3. Diseñar un programa que permita manejar los datos de los estudiantes de la sección de
estructuras discretas II. Los datos del estudiante son: cédula, nombres, apellidos, sexo, nota.
La inserción de los datos está condicionada de la manera siguiente: Si la nota del estudiante
es mayor a 5,50 puntos, el registro debe almacenarse en una lista. Si la nota del estudiante es
menor o igual a 5,50 puntos, el registro debe almacenarse en una pila. La escala de nota está
comprendida entre 1 y 10 puntos. Se deben validar la entrada de la notas. El programa no
puede permitir cargar notas con un valor que no este comprendido entre dichos valores. Una
 vez cargados los datos, el programa debe mostrar: a) Promedio de notas de la sección, b)
Total de estudiantes aprobados, c)Total de estudiantes reprobados, d) Los datos de la persona
con la nota mas alta.

4. Crear un método en la clase pila que permita comparar dos pilas, a fin de determinar si
ambas son iguales o no.

5. Desarrollar un programa que permita manejar información personal y académica de los

estudiantes inscritos en la sección 1 de la asignatura base de datos, utilizando como
estructura de almacenamiento una pila. Los datos que se deben cargar por cada estudiante
son los siguientes: cédula, apellido, nombre, sexo, correo electrónico, nota obtenida en el
primero, segundo y tercer lapso. El programa debe calcular la nota final obtenida, una vez
ingresada las notas obtenidas en cada uno de los lapsos. Las operaciones que debe ofrecer el
programa al usuario son: a) agregar estudiante, b) buscar estudiante por cédula, c) buscar por
apellido, d) mostrar listado de estudiantes cargados, e) mostrar cantidad de estudiantes
aprobados, f) mostrar cantidad estudiantes reprobados, g) eliminar estudiante, h) mostrar el
promedio obtenido por la sección. Se recomienda utilizar un menú de opciones, donde se
muestren cada una de las operaciones que pueden realizarse. Puede crearse una clase
estudiante o una estructura con los atributos indicados para el estudiante.