code. compile. run. debug. share.
#include <iostream>
#include "Stack.h"
#include "Cola.h"
#include "Heap.h"
//para ejemplo de utilización de clases
#include "Persona.h"
using namespace std;
//Cola Especializada
void mostrarCola(Cola<Persona> c) {
while (!c.vacio()) {
Persona p = c.extraer();
p.ver();
}
}
//Pila Especializada
void mostrarPila(Stack<Persona> c) {
while (!c.empty()) {
Persona p = c.pop();
p.ver();
}
}
//Cola Especializada
void mostrarHeap(Heap<Persona> c) {
while (!c.vacio()) {
Persona p = c.extraer();
p.ver();
}
}
int main() {
Persona p1("Adrian",28,167);
Persona p2("David",30,170);
Persona p3("Fabian",20,169);
Persona p4("Laura",35,165);
Persona p5("Yelka",32,162);
Persona p6("Yuri",27,173);
cout << "Ejemplo de Cola" << endl;
Cola<Persona> la_cola;
la_cola.agregar(p1);
la_cola.agregar(p2);
la_cola.agregar(p3);
la_cola.agregar(p4);
la_cola.agregar(p5);
la_cola.agregar(p6);
mostrarCola(la_cola);
cout << endl << endl;
cout << "Ejemplo de Pila" << endl;
Stack<Persona> la_pila;
la_pila.push(p1);
la_pila.push(p2);
la_pila.push(p3);
la_pila.push(p4);
la_pila.push(p5);
la_pila.push(p6);
mostrarPila(la_pila);
cout << endl << endl;
cout << "Ejemplo de Heap (cola de prioridad)" << endl;
Heap<Persona> el_heap;
el_heap.agregar(p1, p1.getEstatura() );
el_heap.agregar(p2, p2.getEstatura() );
el_heap.agregar(p3, p3.getEstatura() );
el_heap.agregar(p4, p4.getEstatura() );
el_heap.agregar(p5, p5.getEstatura() );
el_heap.agregar(p6, p6.getEstatura() );
mostrarHeap(el_heap);
cout << endl << endl;
cout << "Ejemplo de Ordenar al Reves (Heap y Pila)" << endl;
Heap<Persona> otro_heap;
Stack<Persona> otra_pila;
// paso 1: colocamos los elementos en el Heap
otro_heap.agregar(p1, p1.getEdad() );
otro_heap.agregar(p2, p2.getEdad() );
otro_heap.agregar(p3, p3.getEdad() );
otro_heap.agregar(p4, p4.getEdad() );
otro_heap.agregar(p5, p5.getEdad() );
otro_heap.agregar(p6, p6.getEdad() );
// paso 2: vaciamos el heap, metemos los elementos en una pila
while (!otro_heap.vacio())
{
otra_pila.push(otro_heap.extraer());
}
// paso 3: salen al reves:
mostrarPila(otra_pila);
cout << endl << endl;
}
#ifndef STACK_H_INCLUDED
#define STACK_H_INCLUDED
#include <stack>
#include <iostream>
using namespace std;
template <class Tipo>
class Stack : private stack<Tipo> {
public:
void push(Tipo _valor) {
stack<Tipo>::push(_valor);
}
Tipo pop() {
Tipo temp = stack<Tipo>::top();
stack<Tipo>::pop();
return temp;
}
bool empty () {
return stack<Tipo>::empty();
}
};
#endif // STACK_H_INCLUDED
#ifndef COLA_H
#define COLA_H
using namespace std;
#include <queue>
template <class Tipo>
class Cola : private std::queue<Tipo> {
public:
Tipo extraer() {
Tipo a = queue<Tipo>::front();
queue<Tipo>::pop();
return a;
}
void agregar(Tipo valor) {
queue<Tipo>::push(valor);
}
bool vacio() {
return queue<Tipo>::empty();
}
};
#endif // COLA_H
#ifndef HEAP_H_INCLUDED
#define HEAP_H_INCLUDED
#include <queue>
using namespace std;
#include <queue>
template <class T> class Heap {
public:
Heap() {};
virtual ~Heap() {};
void agregar(T dato, int prioridad) {
ParPrioridadDato par;
par.first = prioridad;
par.second= dato;
h2.push(par);
};
T extraer(){
ParPrioridadDato par = h2.top();
h2.pop();
return par.second;
}
bool vacio() {
return h2.empty();
}
private:
typedef std::pair<int, T> ParPrioridadDato; // Prioridad, orden
class ComparePrioridad {
public:
bool operator() (ParPrioridadDato a, ParPrioridadDato b) {
return a.first > b.first;
}
};
std::priority_queue<ParPrioridadDato, std::vector<ParPrioridadDato>, ComparePrioridad> h2;
};
#endif // HEAP_H_INCLUDED
#ifndef PERSONA_H
#define PERSONA_H
class Persona {
private:
string nombre;
int edad;
int estatura;
public:
Persona(){
this->nombre = "";
this->edad = 0;
this->estatura = 0;
}
Persona(string nombre, int agnos, int cms){
this->nombre = nombre;
this->edad = agnos;
this->estatura = cms;
}
void ver(){
cout <<"información de " << this->nombre
<< ", edad : " << this->edad
<< ", y mide : " << this->estatura
<< endl;
}
int getEdad(){
return this->edad;
}
int getEstatura(){
return this->estatura;
}
};
#endif
Compiling Program...
Standard Input:
Interactive Console
Text
Program is not being debugged. Click "Debug" button to start program in debug mode.
| # | Function | File:Line |
|---|
| Variable | Value |
|---|
| Register | Value |
|---|
| Expression | Value |
|---|
| # | Description |
|---|