// repairs the heap if this_node is in the wrong place in the heap
void updateHeapPositionOfNode(node* this_node)
{
tempInd = this_node->heapIndex;
// need to repair heap differently depending on the key vector of heapNode[tempInd]
if(tempInd > parentOfLast) // then can't go down any more so only try to go up
bubbleUp(tempInd);
else if(tempInd == 0) // can't go up any more so only try to go down
bubbleDown(tempInd);
else if(nodeLess(heapNode[tempInd], heapNode[(tempInd-1)/2])) // this node is less than its parent so try to go up
bubbleUp(tempInd);
else // this node is not less than its parent, so try to go down
bubbleDown(tempInd);
}
/*Utliza a heap para fazer a ordenacao*/
void heapSort(Elem v[],int N){
int i;
for(i=N-1;i>0;i--) {
swap(v,0,i);
bubbleDown(v,i);
}
}
int PQueue::deQueue()
{
if(qsize == 0)
return NULL;
else {
int min = queue[1];
if(qsize>1) {
int lastElem = queue[qsize];
float lastW = weight[qsize];
queue[1] = lastElem;
weight[1] = lastW;
qsize--;
// mark
//lastElem->pqIndex = 1;
// heapify
bubbleDown(1);
} else {
//queue.erase(queue.begin()+1);
qsize = 0;
}
// mark
//min->pqIndex = -1;
return min;
}
}
// delete the key associated with index i
void deleteKey(int i) {
int ind = index[i];
swap(ind, N--);
bubbleUp(ind);
bubbleDown(ind);
index[i] = -1;
}
uint32_t heap_deleteMaxWithPriority(Heap *heap, uint32_t *priority) {
Node max = heap->elements[0];
if (priority) {
*priority = max.priority;
}
// Put the last element at the top
heap->elements[0] = heap->elements[heap->numElements - 1];
heap->numElements--;
// Bubble down
bubbleDown(heap, 0);
// Reallocate to a smaller array if necessary
if (heap->numElements <= heap->size / 4) {
int32_t newSize = MAX(MIN_HEAP_SIZE, heap->size / 2);
heap->size = newSize;
#if DEBUG
printf("\ndecreasing heap size to %u...\n\n", newSize);
#endif
heap->elements = realloc(heap->elements, newSize * sizeof(Node));
}
return max.value;
}
// preserve the heap invariant, by moving a violating
// parent downward
void binheap::bubbleDown(idx i, idx size) {
idx left_i = left(i);
idx right_i = right(i);
if (right_i < size && heap[right_i] < heap[i]) {
if (heap[left_i] < heap[right_i]) {
std::swap(heap[left_i], heap[i]);
bubbleDown(left_i, size);
} else {
std::swap(heap[right_i], heap[i]);
bubbleDown(right_i, size);
}
} else if (left_i < size && heap[left_i] < heap[i]) {
std::swap(heap[left_i], heap[i]);
bubbleDown(left_i, size);
}
}
// delete the minimal key and return its associated index
// Warning: Don't try to read from this index after calling this function
int deleteMin() {
int min = heap[1];
swap(1, N--);
bubbleDown(1);
index[min] = -1;
heap[N+1] = -1;
return min;
}
/*Extrai o valor minimo da heap (primeiro)*/
int extractMin(Heap *h, Elem *x){
if(h->used == 0) return 1;
*x = h->values[0];
h->used--;
h->values[0] = h->values[h->used];
bubbleDown(h->values,h->used);
return 0;
}
string HeapPriorityQueue::dequeueMin() {
if (isEmpty()) {
error("HeapPriorityQueue is empty. No dequeuing.");
}
string returnStr = elems[1];
elems[1] = elems[size()];
logicalLength--;
bubbleDown(1);
return returnStr;
}
/* helper function: bubbleDown(int index)
*
* lexicographically repairs the heap
* by swapping elements with their children
*/
void HeapPriorityQueue::bubbleDown(int index) {
int childIndex1 = PARENT_CHILD_MULT*index;
int childIndex2 = PARENT_CHILD_MULT*index + 1;
bool has1Child = size() == childIndex1;
bool has2Children = size() >= childIndex2;
if (has2Children) {
if (elems[childIndex1] < elems[childIndex2] &&
elems[index] > elems[childIndex1]) {
swap(index, childIndex1);
bubbleDown(childIndex1);
} else if (elems[index] > elems[childIndex2]) {
swap(index, childIndex2);
bubbleDown(childIndex2);
}
}else if (has1Child &&
elems[index] > elems[childIndex1]) {
swap(index, childIndex1);
}
}
string HeapPriorityQueue::dequeueMin() {
if (isEmpty()) error("The queue is empty.");
string min = pQueue[1];
pQueue[1] = pQueue[numAllocated];
numAllocated--;
bubbleDown(1);
return min;
}
Node* Heap::removeMin() {
Node *temp = arr[lastPosition];
arr[lastPosition] = arr[0];
arr[0] = temp;
temp = arr[lastPosition];
arr[lastPosition] = NULL;
lastPosition--;
bubbleDown(0);
numItems--;
return temp;
}
// pHeapBase -> (zero element is not used) and we cannot overflow.
// sorting from pHeapBase+1 to pHeapBase+heapSize;
void cPointSearchSimple_t::heapSort(__int64* pHeapBase, int32_t heapSize) {
// construct the heap now.
for (int32_t ii = heapSize / 2; ii > 0; ii--) {
bubbleDown(pHeapBase, heapSize, ii);
}
__int64* pLast = pHeapBase + heapSize;
__int64* pTop = pHeapBase + 1;
for (int32_t ii = 1; ii < heapSize - 1; ii++) {
__int64 vLast = *pLast;
*pLast = *pTop;
*pTop = vLast;
bubbleDown(pHeapBase, heapSize - ii, 1);
pLast--;
}
// for last one, we does not need bubble down.
__int64 vLast = *pLast;
*pLast = *pTop;
*pTop = vLast;
}
// deletes this_node from the heap, and then repairs the heap
void deleteNodeFromHeap(node* this_node)
{
this_node->inHeap = closed;
tempInd = this_node->heapIndex;
this_node->heapIndex = -1;
// if this was the last node on the heap, then we are done
if(tempInd == indexOfLast)
{
indexOfLast--;
if(indexOfLast == 0)
parentOfLast = -1;
else
parentOfLast = (indexOfLast-1)/2;
return;
}
else if(tempInd == 0) // if this is the top node, then just pop it
{
popHeap();
return;
}
// put last node from heap where this node used to be
heapNode[tempInd] = heapNode[indexOfLast];
heapNode[tempInd]->heapIndex = tempInd;
// take care of heap values at old last node position
heapNode[indexOfLast] = NULL;
indexOfLast--;
if(indexOfLast == 0)
parentOfLast = -1;
else
parentOfLast = (indexOfLast-1)/2;
// need to repair heap differently depending on the key vector of heapNode[tempInd]
if(tempInd > parentOfLast) // then can't go down any more so only try to go up
{
bubbleUp(tempInd);
}
else if(nodeLess(heapNode[tempInd], heapNode[(tempInd-1)/2])) // this node is less than its parent so try to go up
{
bubbleUp(tempInd);
}
else // this node is not less than its parent, so try to go down
{
bubbleDown(tempInd);
}
}
void bubbleDown(POTNODE a, GRAPH G, POT P, int last)
{
POTNODE child;
if (MYDEBUG) printf("Entering bubbleDown.\n");
child = 2*a;
if (child < last &&
priority(child+1, G, P) < priority(child, G, P))
++child;
if (child <= last &&
priority(a, G, P) > priority(child, G, P)) {
swap(a, child, G, P);
bubbleDown(child, G, P, last);
}
if (MYDEBUG) printf("Exiting bubbleDown.\n");
}
void Heap::bubbleDown(int pos) {
int min = pos;
if (getLeftIndex(pos) <= lastPosition && arr[getLeftIndex(pos)]->priority < arr[min]->priority) {
min = getLeftIndex(pos);
}
if (getRightIndex(pos) <= lastPosition && arr[getRightIndex(pos)]->priority < arr[min]->priority) {
min = getRightIndex(pos);
}
if (min != pos) {
Node *temp = arr[pos];
arr[pos] = arr[min];
arr[min] = temp;
bubbleDown(min);
}
}
// removes the top valued node from the heap and returns a pointer to it
node* popHeap()
{
node* oldTopNode = heapNode[0];
heapNode[0] = heapNode[indexOfLast];
heapNode[0]->heapIndex = 0;
heapNode[indexOfLast] = NULL;
indexOfLast--;
if(indexOfLast == 0)
parentOfLast = -1;
else
parentOfLast = (indexOfLast-1)/2;
bubbleDown(0);
oldTopNode->inHeap = closed;
oldTopNode->heapIndex = -1;
return oldTopNode;
}
void HeapPriorityQueue::bubbleDown(int parent) {
int leftChild = 2 * parent;
int rightChild = 2 * parent + 1;
// If no children
if (leftChild > numAllocated) return;
// If parent less than equal both children no swap needed
if (pQueue[parent] <= pQueue[leftChild]) {
if (rightChild > numAllocated) return;
if (pQueue[parent] <= pQueue[rightChild]) return;
}
int smaller = leftChild;
if (pQueue[rightChild] < pQueue[leftChild]) smaller = rightChild;
swap(pQueue[parent], pQueue[smaller]);
bubbleDown(smaller);
}
T CPriorityHeap<T>::deleteKey(const T key)
{
T res;
for(typename vector< CPriority<T> >::iterator it = heap.begin(); it != heap.end(); ++it) {
if (key == it->key)
{
T delKey = it->key;
it->key = heap.back().key;
it->priority = heap.back().priority;
heap.pop_back();
index--;
bubbleDown(it - heap.begin());
return delKey;
}
}
return res;
}
void Dijkstra(GRAPH G, POT P, int *pLast)
{
NODE u, v; /* v is the node we select to settle */
LIST ps; /* ps runs down the list of successors of v;
u is the successor pointed to by ps */
if (MYDEBUG) printf("Entering Dijkstra.\n");
initialize(G, P, pLast);
while ((*pLast) > 1) {
v = P[1];
swap(1, *pLast, G, P);
--(*pLast);
bubbleDown(1, G, P, *pLast);
ps = G[v].successors;
while (ps != NULL) {
u = ps->nodeName;
if (G[u].distance > G[v].distance + ps->nodeLabel) {
G[u].distance = G[v].distance + ps->nodeLabel;
bubbleUp(G[u].toPOT, G, P);
}
ps = ps->next;
}
}
}
string HeapPriorityQueue::dequeueMin() {
//If there are no elements, return error to the user.
if(isEmpty()){
error("There are no elements in the queue.");
}
//Obtain result, which is the root.
string result = *root;
//Swap the root and the last element added.
string* end = elements[total + 1];
string* front = elements[1];
front = end;
root = front;
//Reorder elements so as to maintain the integrity of the tree.
bubbleDown(root, elements);
//Increment the total.
total --;
//Return the result.
return result;
}
void binheap::removeMin()
{
heap[0] = heap[heap.size() - 1];
heap.pop_back();
bubbleDown(0);
}
void binheap::bubbleDown(idx i) {
bubbleDown(i, size());
}
// change the key associated with index i to the specified value
void changeKey(int i, int key) {
keys[i] = key;
bubbleUp(index[i]);
bubbleDown(index[i]);
}
// increase the key associated with index i to the specified value
void increaseKey(int i, int key) {
keys[i] = key;
bubbleDown(index[i]);
}
