**Data Structure Algorithm for Heap Operations pseudo-code.**

**After knowing and completely understanding this algorithm for Heap Operations . You will be able to write a Data Structure Programs for Heap Operations in any language. The basic ideology and idea behind all the programs will be same. Yes the programs will differ according to the syntax and semantics of the language. This is a part of**Mumbai University MCA Colleges

**Data Structure MCA Sem 2**

**ReheapUp:-**
Algorithm ReheapUp(heap, newNode)

1 if(newNode <> 0) (* if not root of heap *)

1 parent := (newNode-1)/2

2 if (heap[newNode]>heap[parent]) (* child greater than parent *)

1 hold = heap[parent]

2 heap[parent] = heap[newNode] (* exchange *)

3 heap[newNode] = hold

4 ReheapUp (heap, parent) (*continue reheapUP *)

3 end if

2 end if

End ReheapUp

__Heap Insertion:-__
Algorithm InsertHeap(heap, last, data) : BOOLEAN

1 if (last = HeapSize -1)

1 return FALSE (* over the heap size limitation *)

2 increment last (* increase the size of the heap *)

3 heap[last] = data (* put the data at the last position *)

4 ReheapUp(heap, last) (* restore the heap *)

5 return TRUE

End InsertHeap

__ReheapDown:-__
Algorithm ReheapDown (heap, root, last)

1 if ((root*2 +1) <= last) (* There is at least left child *)

2 leftKey := heap[root*2 +1] (* left child value *)

3 rightChild := FALSE (* assume no right child)

1 if ((root*2 + 2) <= last) (* There is also right child *)

1 rightKey := heap[root*2 +2] (* right child value *)

2 rightChild := TRUE

2 end if

3 largeChildKey := leftKey;

4 largeChildIndex := root*2 + 1; (* assume left child larger *)

5 if (rightChild AND leftKey < rightKey)

1 largeChildKey := rightKey; (* right child exists and is larger *)

2 largeChildIndex := root*2 +2;

6 end if

7 if (heap[root] < largeChildKey) (* exchange larger child with root *)

1 hold := heap[root];

2 heap[root] := heap[largeChildIndex];

3 heap[largeChildIndex] := hold;

4 reheapDown (heap, largeChildIndex, last);

8 end if

2 end if

end ReheapDown

**Heap Deletetion**

Algorithm DeleteHeap(heap, last, dataOut)

1 if (last < 0) (* empty heap *)

1 return FALSE

2 dataOut := heap[0] (* remove the largest data at root *)

3 heap[0] := heap[last] (* restore the shape *)

4 decrement last

5 reheapDown (heap, 0, last) (* restore the order property *)

6 return TRUE

End DeleteHeap

__Algorithm for converting to max heap:-__
Algorithm CreateHeap(list)

1 set index to 1

2 loop (index <= listLength)

1 reheapUp(list, index)

2 increment index

3 end loop

End CreateHeap

**Heap Sort Algorithm:-**
Algorithm HeapSort(list, last)

(* Create a heap *)

1 CreateHeap(list)

2 sorted := last;

3 loop (sorted > 0)

1 holdData := list[0] (* exchange 0 and sorted *)

2 list[0] := list[sorted]

3 list[sorted] = holdData

4 decrement sorted

5 reheapDown (list, 0, sorted);

4 end loop

End HeapSort

Hope this Algorithm is useful to you in some sense or other. Keep on following this blog for more Mumbai University MCA College Programs. Happy Programming and Studying.

Hope this Algorithm is useful to you in some sense or other. Keep on following this blog for more Mumbai University MCA College Programs. Happy Programming and Studying.