building a heap. problems with the void insert function

[Fernanda]

i need to write the code for the void insert into a heap. I have an error that fail compilation.
here is my code, can someone... help me out please
what should do

void insert (const KEY &key, const VALUE &value)
I wrote something like this:

void insert (const KEY &key, const VALUE &value) 

************************************************************
#pragma once

#include "UnderFlowException.h"
#include "overFlowException.h"
#include "Node.h"

template <typename KEY, typename VALUE>
class Heap
{
private:
	int maximumSize;
	int lastUsedIndex;
	Node<KEY,VALUE> *array;

public:
	Heap (int maximumSize): maximumSize(maximumSize), lastUsedIndex(-1)
	{
		array = new Node<KEY,VALUE>[maximumSize];
	}
	//************************************************************
	void insert (const KEY &key, const VALUE &value) 
	// insert code  here
	{
		for (VALUE i = 0; i <maximumSize; i++)
			 KEY	current = key;
			  VALUE currentIndex = *array; 

		/*Node = new Node<KEY,VALUE>;
		heap.push_back(unit);*/
		//reheapUp(maximumSize);


	}
	//*****************************************************
	VALUE remove ( )
	{
		VALUE result;

		if (!isEmpty())
		{
			result = array[0].value;
			array[0] = array[lastUsedIndex--];
			reheapDown();
		}
		else
			throw UnderFlowException();

		return result;
	}

	bool isEmpty()
	{
		return getSize() == 0;
	}

	bool isFull()
	{
		return getSize() == getMaximumSize();
	}

	int getSize()
	{
		return lastUsedIndex + 1;
	}

	int getMaximumSize()
	{
		return maximumSize;
	}

private:
	static int parentIndexOf(int index)
	{
		return (index - 1) / 2;
	}

	static int leftChildOf(int index)
	{
		return index * 2 + 1;
	}

	static int rightChildOf(int index)
	{
		return index * 2 + 2;
	}

	int largestChildOf (int index)
	{
		int result;
		int rightChildIndex = rightChildOf(index);
		int leftChildIndex = leftChildOf(index);

		if (rightChildIndex <= lastUsedIndex)
		{
			if (array[rightChildIndex].key > array[leftChildIndex].key)
				result = rightChildIndex;
			else
				result = leftChildIndex;
		}
		else if (leftChildIndex <= lastUsedIndex)
			result = leftChildIndex;
		else
			result = -1;

		return result;
	}

	void swap (int i, int j)
	{
		Node<KEY,VALUE> temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}
	//*********************************************************
	void reheapUp () // insert code here
	{
		int parent;
		Node temp;

		if(bottom > root)
		{
			parent = (bottom - 1) / 2;
			if(array[parent].getKey() < array[bottom].getKey())
			{
				temp = array[parent];
				array[parent] = array[bottom];
				array[bottom] = temp;
				reheapUp(root, parent);
			}
		}
//********************************************************************

	}

	void reheapDown ()
	{
		int current = 0;
		int largestChildIndex = largestChildOf(current);
		while (largestChildIndex > -1 && array[largestChildIndex].key > array[current].key)
		{
			swap(largestChildIndex,current);
			current = largestChildIndex;
			largestChildIndex = largestChildOf(current);
		}
	}
};

[weaknessforcats]

You did not post your header files so I can't compile your code.

[Fernanda]

//This is the Node.h
#pragma once

template <typename KEY, typename VALUE>
class Node
{
public:
	KEY key;
	VALUE value;

	Node( )
	{
	}

	Node(const KEY &key, const VALUE &value): key(key), value(value)
	{
	}
};
//This is the overFlowException

#pragma once

#include <exception>
using namespace std;

class overFlowException: public exception
{
};

//This is the UnderflowExceptio
#pragma once

#include <exception>
using namespace std;

class UnderFlowException: public exception
{
};

//this is the main.cpp
#include <stdlib.h>
#include <iostream>
using namespace std;

#include "Heap.h"

int main()
{
	Heap<int,double> heap(30);

	for (int i = 0; i < heap.getMaximumSize(); i++)
	{
		int newValue = rand() % 100 + 1;
		heap.insert(newValue,(double)newValue);
	}

	try
	{
		heap.insert(0,0);
		cout << "We should not be here!" << endl;
	}
	catch (overFlowException &)
	{
		cout << "Caught overflow exception" << endl;
	}

	while (!heap.isEmpty())
		cout << heap.remove() << endl;

	try
	{
		heap.remove();
		cout << "We should not be here!" << endl;
	}
	catch (UnderFlowException &)
	{
		cout << "Caught underflow exception" << endl;
	}

	system("pause");
	return EXIT_SUCCESS;
}

[weaknessforcats]

I am still missing heap.h.

[Fernanda]

building a heap

UnderflowException.h

#pragma once

#include <exception>
using namespace std;

class UnderflowException: public exception
{
};


OverflowException.h
#pragma once

#include <exception>
using namespace std;

class OverflowException: public exception
{
};



Node.h
#pragma once

template <typename KEY, typename VALUE>
class Node
{
public:
	KEY key;
	VALUE value;

	Node( )
	{
	}

	Node(const KEY &key, const VALUE &value): key(key), value(value)
	{
	}
};
	



Main.cpp
#include <stdlib.h>
#include <iostream>
using namespace std;

#include "Heap.h"

int main()
{
	Heap<int,double> heap(30);

	for (int i = 0; i < heap.getMaximumSize(); i++)
	{
		int newValue = rand() % 100 + 1;
		heap.insert(newValue,(double)newValue);
	}

	try
	{
		heap.insert(0,0);
		cout << "We should not be here!" << endl;
	}
	catch (OverflowException &)
	{
		cout << "Caught overflow exception" << endl;
	}

	while (!heap.isEmpty())
		cout << heap.remove() << endl;

	try
	{
		heap.remove();
		cout << "We should not be here!" << endl;
	}
	catch (UnderflowException &)
	{
		cout << "Caught underflow exception" << endl;
	}

	system("pause");
	return EXIT_SUCCESS;
}





Heap.h
#pragma once

#include "UnderflowException.h"
#include "OverflowException.h"
#include "Node.h"

template <typename KEY, typename VALUE>
class Heap
{
private:
	int maximumSize;
	int lastUsedIndex;
	Node<KEY,VALUE> *array;

public:
	Heap (int maximumSize): maximumSize(maximumSize), lastUsedIndex(-1)
	{
		array = new Node<KEY,VALUE>[maximumSize];
	}




	void insert (const KEY &key, const VALUE &value)
	{






	}

	VALUE remove ( )
	{
		VALUE result;

		if (!isEmpty())
		{
			result = array[0].value;
			array[0] = array[lastUsedIndex--];
			reheapDown();
		}
		else
			throw UnderflowException();

		return result;
	}

	bool isEmpty()
	{
		return getSize() == 0;
	}

	bool isFull()
	{
		return getSize() == getMaximumSize();
	}

	int getSize()
	{
		return lastUsedIndex + 1;
	}

	int getMaximumSize()
	{
		return maximumSize;
	}

private:
	static int parentIndexOf(int index)
	{
		return (index - 1) / 2;
	}

	static int leftChildOf(int index)
	{
		return index * 2 + 1;
	}

	static int rightChildOf(int index)
	{
		return index * 2 + 2;
	}

	int largestChildOf (int index)
	{
		int result;
		int rightChildIndex = rightChildOf(index);
		int leftChildIndex = leftChildOf(index);

		if (rightChildIndex <= lastUsedIndex)
		{
			if (array[rightChildIndex].key > array[leftChildIndex].key)
				result = rightChildIndex;
			else
				result = leftChildIndex;
		}
		else if (leftChildIndex <= lastUsedIndex)
			result = leftChildIndex;
		else
			result = -1;

		return result;
	}

	void swap (int i, int j)
	{
		Node<KEY,VALUE> temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}




	void reheapUp ()
	{








	}

	void reheapDown ()
	{
		int current = 0;
		int largestChildIndex = largestChildOf(current);
		while (largestChildIndex > -1 && array[largestChildIndex].key > array[current].key)
		{
			swap(largestChildIndex,current);
			current = largestChildIndex;
			largestChildIndex = largestChildOf(current);
		}
	}
};

[weaknessforcats]

This code compiles and links for me using Visual Studio 2013.

What is the error you are getting?

[Fernanda]

yes, but i need to know what goes in the void insert
void insert (const KEY &key, const VALUE &value)
{
}
any help i will appreciate, thank you

[Fernanda]

it compiles but how can i set the whole insert function