public void HeapifyDown(int pos)
{
if (pos <= _count / 2)
{
if (_holdthis[pos * 2] != null && _holdthis[(pos * 2) + 1] == null)
{
if (_holdthis[pos].Priority < _holdthis[pos * 2].Priority)
{
PQNode temp = _holdthis[pos * 2];
_holdthis[pos * 2] = _holdthis[pos];
_holdthis[pos] = temp;
HeapifyDown(pos * 2);
}
}
else if (_holdthis[pos * 2] != null && _holdthis[(pos * 2) + 1] != null && _holdthis[pos * 2].Priority > _holdthis[(pos * 2) + 1].Priority)
{
PQNode temp = _holdthis[pos * 2];
_holdthis[pos * 2] = _holdthis[pos];
_holdthis[pos] = temp;
HeapifyDown(pos * 2);
}
else
{
PQNode temp = _holdthis[(pos * 2) + 1];
_holdthis[(pos * 2) + 1] = _holdthis[pos];
_holdthis[pos] = temp;
HeapifyDown((pos * 2) + 1);
}
}
}
/**Using heapsort, produce and return an array of PQNode instances sorted in non-decreasing order of priority.
* Despite the typical convention of ignoring index 0 of the backing array, the array you return from this method
* should start at 0 and continue to index n-1 (like a typical array in Java or C#)
**/
public PQNode[] ToSortedArray()
{
PQNode [] outputArray = new PQNode[_count];
Array.Copy(_holdthis, 1, outputArray, 0, _count);
HeapSort(outputArray);
return(outputArray);
}
//Removes the root node of the queue and returns it, adjusts the count, and heapifies as needed.
public PQNode Dequeue()
{
PQNode temp = _holdthis[1];
_holdthis[1] = _holdthis[_count];
_holdthis[_count] = null;
_count--;
HeapifyDown(1);
return(temp);
}
private void HeapifyUp(int pos)
{
if (pos > 1)
{
int parentPos = (pos) / 2;
if (_holdthis[pos].Priority > _holdthis[parentPos].Priority)
{
PQNode temp = _holdthis[parentPos];
_holdthis[parentPos] = _holdthis[pos];
_holdthis[pos] = temp;
HeapifyUp(parentPos);
}
}
}
private void HeapSort(PQNode[] a)
{
int count = a.Length;
int end = count - 1;
while (end > 0)
{
//swap max value of the heap with the last element of the heap
PQNode tmp = a[end];
a[end] = a[0];
a[0] = tmp;
//put the heap back in max-heap order
Heapify(a, end - 1);
//decrease size of the heap so that the previous max value will stay in its new place
end--;
}
}
public void Heapify(PQNode[] a, int end)
{
int root = 0;
while ((root * 2) + 1 <= end)
{
int child = root * 2 + 1;
if (child + 1 <= end && a[child].Priority < a[child + 1].Priority)
child = child + 1;
if (a[root].Priority < a[child].Priority)
{
PQNode tmp = a[root];
a[root] = a[child];
a[child] = tmp;
root = child;
}
else
return;
}
}
/** Takes in the priority and value as parameters.Creates a new PQNode with this value and adds the node to the queue,
* adjusts the count, and heapifies as needed. When heapifying, a child node with equal priority to its parent does NOT
* promote and the heapifying of that particular child node stops.
* 1. ignore zero
* 2. priority matters
* 3. p = n , left = 2n, right = 2n + 1
**/
public void Enqueue(int priority, int value)
{
_count++;
PQNode addThis = new PQNode(priority, value);
if (_count == _holdthis.Length)
{
PQNode[] doubleHold = new PQNode[_holdthis.Length * 2];
Array.Copy(_holdthis, 0, doubleHold, 0, _count);
_holdthis = doubleHold;
}
_holdthis[_count] = addThis;
if (_count > 1)
{
HeapifyUp(_count);
}
}
/** Takes in the priority and value as parameters.Creates a new PQNode with this value and adds the node to the queue,
adjusts the count, and heapifies as needed. When heapifying, a child node with equal priority to its parent does NOT
promote and the heapifying of that particular child node stops.
1. ignore zero
2. priority matters
3. p = n , left = 2n, right = 2n + 1
**/
public void Enqueue(int priority, int value)
{
_count++;
PQNode addThis = new PQNode(priority, value);
if (_count == _holdthis.Length)
{
PQNode[] doubleHold = new PQNode[_holdthis.Length * 2];
Array.Copy(_holdthis, 0, doubleHold, 0, _count);
_holdthis = doubleHold;
}
_holdthis[_count] = addThis;
if (_count > 1)
{
HeapifyUp(_count);
}
}
public void Heapify(PQNode[] a, int end)
{
int root = 0;
while ((root * 2) + 1 <= end)
{
int child = root * 2 + 1;
if (child + 1 <= end && a[child].Priority < a[child + 1].Priority)
{
child = child + 1;
}
if (a[root].Priority < a[child].Priority)
{
PQNode tmp = a[root];
a[root] = a[child];
a[child] = tmp;
root = child;
}
else
{
return;
}
}
}
private void HeapSort(PQNode[] a)
{
int count = a.Length;
int end = count - 1;
while (end > 0)
{
//swap max value of the heap with the last element of the heap
PQNode tmp = a[end];
a[end] = a[0];
a[0] = tmp;
//put the heap back in max-heap order
Heapify(a, end - 1);
//decrease size of the heap so that the previous max value will stay in its new place
end--;
}
}
/**Using heapsort, produce and return an array of PQNode instances sorted in non-decreasing order of priority.
Despite the typical convention of ignoring index 0 of the backing array, the array you return from this method
should start at 0 and continue to index n-1 (like a typical array in Java or C#)
**/
public PQNode[] ToSortedArray()
{
PQNode [] outputArray = new PQNode[_count];
Array.Copy(_holdthis, 1, outputArray, 0, _count);
HeapSort(outputArray);
return outputArray;
}
