public HeapNode <K, T> pop(int level, int offset)
{
bool right = offset > Math.Pow(2, level) / 2;
switch (level)
{
case 0:
return(this);
case 1:
if (right)
{
HeapNode <K, T> tempNode = _rightChild;
_rightChild = null;
return(tempNode);
}
else
{
HeapNode <K, T> tempNode = _leftChild;
_leftChild = null;
return(tempNode);
}
default:
return(right ? _rightChild.pop(level - 1, offset - (int)Math.Pow(2, level - 1)) : _leftChild.pop(level - 1, offset));
}
}
private void swap(HeapNode <K, T> node1, HeapNode <K, T> node2)
{
T tempElement = node1.Element;
K tempKey = node1.Key;
node1.Element = node2.Element;
node1.Key = node2.Key;
node2.Element = tempElement;
node2.Key = tempKey;
}
public T pop()
{
T element = _rootNode.Element;
if (Level == 0)
{
_rootNode = null;
_nodeCount = 0;
return(element);
}
HeapNode <K, T> lastNode = _rootNode.pop(Level, Offset);
_rootNode.Element = lastNode.Element;
_rootNode.Key = lastNode.Key;
//Decrement nodecount after pop() but before heapDown()
_nodeCount--;
heapDown();
return(element);
}
//public methods
public void push(K key, T element, int level, int offset)
{
bool right = offset > Math.Pow(2, level) / 2;
switch (level)
{
case 0:
_element = element;
_key = key;
heapUp();
break;
case 1:
if (right)
{
_rightChild = new HeapNode <K, T>(this, _priority);
_rightChild.push(key, element, level - 1, offset - 1);
}
else
{
_leftChild = new HeapNode <K, T>(this, _priority);
_leftChild.push(key, element, level - 1, offset);
}
break;
default:
if (right)
{
_rightChild.push(key, element, level - 1, offset - (int)Math.Pow(2, level - 1));
}
else
{
_leftChild.push(key, element, level - 1, offset);
}
break;
}
}
//constructor
public HeapTreeImplementation(HeapPriorityType priorityType)
{
_nodeCount = 0;
_priorityType = priorityType;
_rootNode = new HeapNode <K, T>(null, priorityType);
}
//constructor
public HeapNode(HeapNode <K, T> parent, HeapPriorityType priority)
{
_parent = parent;
_priority = priority;
}
