void decreaseKey( struct MinHeap * minHeap, int target_element, int target_priority ) {
// get the index of target element
int target_element_index = minHeap -> current_position[target_element];
// get the node and update it's dist value
struct MinHeapNode * target_node = minHeap -> array[ target_element_index];
// check if the new priority is lesser then current priority or not
if ( target_priority >= target_node -> priority )
return;
target_node -> priority = target_priority;
// now travel up to fix if any other node up has priority lesser than the current priority
int parent_index = get_parent( target_element_index );
while ( parent_index != -1 && minHeap -> array[parent_index] -> priority > minHeap -> array[ target_element_index]->priority ) {
// set the index of parent to be of target_element_index
minHeap -> current_position[ minHeap -> array[parent_index] -> element ] = target_element_index;
// set the index of target element to be of parent
minHeap -> current_position[ minHeap -> array[target_element_index] -> element ] = parent_index;
// swap the two pointers
swapMinHeapNodes( &minHeap -> array[parent_index], &minHeap -> array[target_element_index]);
// now the target_index will be parent index
target_element_index = parent_index;
// new parent index will be parent of previous parent index
parent_index = get_parent(parent_index);
}
}
void minHeapify ( struct MinHeap * heap, int index ) {
// get the left child index
int left_child_index = left_child ( index );
// get the right child index
int right_child_index = right_child ( index );
// get the current size
int current_size = heap -> current_size;
int smallest = index;
if ( left_child_index < current_size && heap -> array[left_child_index]->priority < heap -> array[smallest]->priority )
smallest = left_child_index;
if ( right_child_index < current_size && heap -> array[right_child_index]->priority < heap -> array[smallest]->priority)
smallest = right_child_index;
if ( smallest != index ) {
MinHeapNode * smallestNode = heap -> array[smallest];
MinHeapNode * currentNode = heap -> array[index];
// set position of smallest node to 'index'
// set position of index node to 'smallest'
heap -> current_position[smallestNode->element] = index;
heap -> current_position[currentNode->element] = smallest;
// swap nodes
swapMinHeapNodes( &heap->array[smallest], &heap->array[index] );
minHeapify( heap, smallest);
}
}
// This is the standard minHeapify function. It does one thing extra.
// It updates the minHapIndex in Trie when two nodes are swapped in
// in min heap
void minHeapify( MinHeap* minHeap, int idx )
{
int left, right, smallest;
left = 2 * idx + 1;
right = 2 * idx + 2;
smallest = idx;
if ( left < minHeap->count &&
minHeap->array[ left ]. frequency <
minHeap->array[ smallest ]. frequency
)
smallest = left;
if ( right < minHeap->count &&
minHeap->array[ right ]. frequency <
minHeap->array[ smallest ]. frequency
)
smallest = right;
if( smallest != idx )
{
// Update the corresponding index in Trie node.
minHeap->array[ smallest ]. root->indexMinHeap = idx;
minHeap->array[ idx ]. root->indexMinHeap = smallest;
// Swap nodes in min heap
swapMinHeapNodes (&minHeap->array[ smallest ], &minHeap->array[ idx ]);
minHeapify( minHeap, smallest );
}
}
