#include <vector>
#include "heap.h"
#include <ostream>
using namespace std;
int main(int argc, const char * argv[]) {
Heap<int> h;
h.insert(5);
h.getHeap();
h.getMaxIndex();
h.getMax();
h.removeMax();
h.removeAtIndex(1);
h.getHeap();
cout<<h;
}
#ifndef Heap_hpp
#define Heap_hpp
#include <stdio.h>
#include <vector>
#include <iterator>
#include <string>
#include <iostream>
template<typename elementType>
class Heap{
private:
std::vector<elementType> myVecrtor;
int mySize = 1; //The minimum size is 1 since the first element is a dummy.
void perculateDown(int root);
void perculateUp();
public:
Heap();
bool checkEmpty();
void insert(elementType iteam);
int getSize();
std::vector<elementType> getHeap();
elementType getMax();
int getMaxIndex();
void removeMax();
void removeAtIndex(int index);
template<typename U>
friend std::ostream& operator<<(std::ostream &out, Heap<U> const &h);
};
template<typename elementType>
Heap<elementType>::Heap(){
}
template <typename elementType>
bool Heap<elementType>::checkEmpty(){
if(mySize > 1)
return true;
else
return false;
}
template <typename elementType>
void Heap<elementType>::insert(elementType iteam){
auto it = mySize;//itterator
//myVecrtor.insert(it, iteam);//insert after first element(dummy)
mySize++;
perculateUp();
}
template <typename elementType>
std::vector<elementType> Heap<elementType>::getHeap(){
return myVecrtor;
}
template <typename elementType>
elementType Heap<elementType>::getMax(){
return myVecrtor[getMaxIndex()];
}
template <typename elementType>
int Heap<elementType>::getMaxIndex(){
int maxIndex = 1;
elementType max = myVecrtor[maxIndex];
for(int i = 0; i < myVecrtor.size(); i++){
if(max < myVecrtor[i])
maxIndex = i;
}
return maxIndex;
}
template <typename elementType>
void Heap<elementType>::removeMax(){
int maxIndex = getMaxIndex();
myVecrtor[maxIndex] = myVecrtor[mySize];
mySize--;
perculateDown(maxIndex);
}
template <typename elementType>
void Heap<elementType>::removeAtIndex(int index){
myVecrtor[index] = myVecrtor[mySize];
mySize--;
perculateDown(index);
}
template <typename elementType>
std::ostream& operator<<(std::ostream &out, const Heap<elementType> &h){//it is giving me the error here
out<<"\t\tHeap:";
for(int i = 0; i < h.mySize; i++){
out<<h.myVecrtor.at(i);
}
return out;
}
template <typename elementType>
void Heap<elementType>::perculateUp(){
int loc = mySize - 1;
int parent = loc /2;
// while(parent >= 1 && myVecrtor[loc] > myVecrtor[parent]){
elementType temp = myVecrtor[parent];
myVecrtor[parent] = myVecrtor[loc];
myVecrtor[loc] = temp;
loc = parent;
parent = loc / 2;
// }
}
template <typename elementType>
void Heap<elementType>::perculateDown(int root){
int r = root, c = r*2;
while (r < mySize - 1) {
if(c < mySize && myVecrtor[c] < myVecrtor[c+1])
c++;
if(myVecrtor[r] < myVecrtor[c]){
elementType temp = myVecrtor[r];
myVecrtor[r] = myVecrtor[c];
myVecrtor[c] = temp;
r = c;
c *= 2;
}
else
break;
}
}
#endif /* Heap_hpp */
