# A heap is a specialized form of binary search tree question 1 options

## Related Articles

A Binary Heap is a Binary Tree with the following houses:  It is a Complete Tree. This property of Binary Heap makes them suitable to be stored in an array.A Binary Heap is both Min Heap or Max Heap.In a Min Binary Heap, the choices key at the root ought to be minimum among all keys found in Binary Heap. The same assets ought to be recursively real for all nodes in Binary Tree.Similarly, in a Max Binary Heap, the key at the root should be most amongst all keys present in Binary Heap. The identical belongings should be recursively true for all nodes in Binary Tree.Operation on Binary Heap insert(p): Inserts a new detail with precedence p.extractMax(): Extracts an element with maximum precedence.take away(i): Removes an detail pointed by way of an iterator i.getMax(): Returns an element with maximum precedence.changePriority(i, p): Changes the priority of an element pointed via i to p.Example of A Binary Max Heap Suppose below is the given Binary Heap that follows all the homes of Binary Max Heap.  Now a node with cost 32 need to be insert in the above heap: To insert an detail, attach the brand new detail to any leaf. For Example A node with priority 32 can be brought to the choices leaf of the choices node 11. But this violates the choices heap property. To hold the choices heap assets, shift up the new node 32.  Shift Up Operation get node with 32 at the suitable function: Swap the incorrectly located node with its determine till the choices heap assets is happy. For Example: As node eleven is less than node 32 so, change node 11 and node 32. Then, change node 14 and node 32. And at remaining, switch node 31 and node 32.  ExtractMax: The maximum price is saved at the root of the tree. But the root of the tree cannot be without delay eliminated. First, it’s miles replaced with any one of the choices leaves and then eliminated. For Example: To take away Node 45, it is first changed with node eleven. But this violates the heap assets, so move the choices replaced node down. For that, use shift down operation.  ShiftDown operation: Swap the incorrectly positioned node with a larger infant till the heap belongings is satisfied. For Example: Node eleven is swapped with node 32 then, with node 31 and in last it is swapped with node 14.  ChangePriority: Let the choices changed element shift up or down depending on whether its precedence reduced or expanded. For Example: Change the priority of nodes eleven to 35, because of this alteration the node has to shift up the node so that it will keep the choices heap assets.Remove: To take away an detail, change its priority to a cost larger than the present day most, then shift it up, after which extract it using extract max. Find the modern most the use of getMax.GetMax: The max value is stored at the choices root of the choices tree. To getmax, simply go back the price at the root of the choices tree.Array Representation of Binary HeapSince the choices heap is maintained in shape of a complete binary tree, due to this fact the heap can be represented inside the shape of an array. To preserve the choices tree entire and shallow, whilst placing a new detail insert it inside the leftmost vacant role inside the closing degree i.e., at the stop of our array. Similarly, whilst extracting maximum replace the choices root with the choices last leaf at the choices last stage i.e., the ultimate element of the array. Below is the choices instance of the identical:  Below is the program to put in force Priority Queue the use of Binary Heap:  C++ // C++ code to put into effect priority-queue// using array implementation of// binary heap #include the usage of namespace std; int H[50];int length = -1; // Function to return the choices index of the // determine node of a given nodeint discern(int i)     go back (i – 1) / 2; // Function to return the index of the // left toddler of the choices given nodeint leftChild(int i)     return ((2 * i) + 1); // Function to go back the choices index of the choices// proper baby of the choices given nodeint rightChild(int i)     return ((2 * i) + 2); // Function to shift up the choices node in order// to maintain the heap propertyvoid shiftUp(int i)    whilst (i > zero && H[parent(i)] < H[i])          // Swap figure and present day node        switch(H[parent(i)], H[i]);         // Update i to parent of i        i = determine(i);     // Function to shift down the node in// order to hold the heap propertyvoid shiftDown(int i)    int maxIndex = i;     // Left Child    int l = leftChild(i);     if (l H[maxIndex])         maxIndex = l;         // Right Child    int r = rightChild(i);     if (r H[maxIndex])         maxIndex = r;         // If i not identical as maxIndex    if (i != maxIndex)         change(H[i], H[maxIndex]);        shiftDown(maxIndex);     // Function to insert a new detail// within the Binary Heapvoid insert(int p)    length = length + 1;    H[size] = p;     // Shift Up to hold heap property    shiftUp(length); // Function to extract the detail with// most priorityint extractMax()    int end result = H[0];     // Replace the cost at the root    // with the remaining leaf    H[0] = H[size];    size = size – 1;     // Shift down the choices changed detail    // to keep the choices heap assets    shiftDown(0);    return end result; // Function to trade the priority// of an elementvoid changePriority(int i, int p)    int oldp = H[i];    H[i] = p;     if (p > oldp)         shiftUp(i);        else         shiftDown(i);     // Function to get price of the cutting-edge// maximum elementint getMax()     go back H[0]; // Function to get rid of the choices detail// placed at given indexvoid get rid of(int i)    H[i] = getMax() + 1;     // Shift the choices node to the root    // of the heap    shiftUp(i);     // Extract the choices node    extractMax(); // Driver Codeint most important()     /*         45            /                 31      14          /      /           13  20  7   11        /         12   7    Create a priority queue proven in    instance in a binary max heap form.    Queue might be represented inside the    shape of array as:    forty five 31 14 thirteen 20 7 11 12 7 */     // Insert the choices element to the choices    // precedence queue    insert(forty five);    insert(20);    insert(14);    insert(12);    insert(31);    insert(7);    insert(eleven);    insert(thirteen);    insert(7);     int i = zero;     // Priority queue earlier than extracting max    cout << "Priority Queue : ";    even as (i <= length)         cout << H[i] << " ";        i++;         cout << "n";     // Node with maximum priority    cout << "Node with maximum priority : "         << extractMax() << "n";     // Priority queue after extracting max    cout << "Priority queue after "         << "extracting maximum : ";    int j = 0;    at the same time as (j <= length)         cout << H[j] << " ";        j++;         cout << "n";     // Change the concern of detail    // gift at index 2 to 49    changePriority(2, forty nine);    cout << "Priority queue after "         << "priority alternate : ";    int ok = zero;    whilst (k <= size)         cout << H[k] << " ";        okay++;         cout << "n";     // Remove detail at index 3    take away(3);    cout << "Priority queue after "         << "eliminating the element : ";    int l = 0;    even as (l <= length)         cout << H[l] < 0 &&         H[parent(i)] < H[i])      // Swap determine and modern node    swap(determine(i), i);     // Update i to parent of i    i = determine(i);   // Function to shift down the node in// order to maintain the choices heap propertystatic void shiftDown(int i)  int maxIndex = i;   // Left Child  int l = leftChild(i);   if (l H[maxIndex])      maxIndex = l;     // Right Child  int r = rightChild(i);   if (r H[maxIndex])      maxIndex = r;     // If i not identical as maxIndex  if (i != maxIndex)      switch(i, maxIndex);    shiftDown(maxIndex);   // Function to insert a// new detail in// the Binary Heapstatic void insert(int p)  size = length + 1;  H[size] = p;   // Shift Up to hold  // heap assets  shiftUp(length); // Function to extract// the detail with// most prioritystatic int extractMax()  int result = H[0];   // Replace the fee  // at the root with  // the choices ultimate leaf  H[0] = H[size];  length = size – 1;   // Shift down the choices changed  // element to hold the choices  // heap property  shiftDown(0);  return end result; // Function to alternate the priority// of an elementstatic void changePriority(int i,                           int p)  int oldp = H[i];  H[i] = p;   if (p > oldp)      shiftUp(i);    else      shiftDown(i);   // Function to get value of// the choices cutting-edge maximum elementstatic int getMax()  return H[0]; // Function to remove the choices element// located at given indexstatic void remove(int i)  H[i] = getMax() + 1;   // Shift the node to the root  // of the heap  shiftUp(i);   // Extract the node  extractMax();   static void switch(int i, int j)  int temp= H[i];  H[i] = H[j];  H[j] = temp; // Driver Codepublic static void important(String[] args)   /*           forty five            /                   31      14          /      /           thirteen  20  7   eleven        /         12   7    Create a priority queue proven in    instance in a binary max heap shape.    Queue may be represented in the    form of array as:    forty five 31 14 13 20 7 eleven 12 7 */   // Insert the detail to the   // priority queue  insert(forty five);  insert(20);  insert(14);  insert(12);  insert(31);  insert(7);  insert(11);  insert(thirteen);  insert(7);   int i = 0;   // Priority queue earlier than extracting max  System.out.print(“Priority Queue : “);  while (i <= size)      System.out.print(H[i] + " ");    i++;     System.out.print("n");   // Node with most precedence  System.out.print("Node with most priority : " +                    extractMax() + "n");   // Priority queue after extracting max  System.out.print("Priority queue after " +                   "extracting most : ");  int j = zero;  while (j <= length)      System.out.print(H[j] + " ");    j++;     System.out.print("n");   // Change the priority of detail  // present at index 2 to 49  changePriority(2, 49);  System.out.print("Priority queue after " +                   "precedence trade : ");  int ok = zero;  even as (ok <= length)      System.out.print(H[k] + " ");    okay++;     System.out.print("n");   // Remove detail at index 3  take away(3);  System.out.print("Priority queue after " +                   "putting off the choices element : ");  int l = zero;  while (l zero and H[parent(i)] < H[i]) :                   # Swap parent and modern-day node        swap(discern(i), i)               # Update i to discern of i        i = figure(i)         # Function to shift down the choices node in# order to maintain the heap propertydef shiftDown(i) :     maxIndex = i           # Left Child    l = leftChild(i)           if (l H[maxIndex]) :             maxIndex = l           # Right Child    r = rightChild(i)           if (r H[maxIndex]) :             maxIndex = r           # If i not same as maxIndex    if (i != maxIndex) :             change(i, maxIndex)        shiftDown(maxIndex)         # Function to insert a # new detail in # the choices Binary Heapdef insert(p) :         international size    size = length + 1    H[size] = p           # Shift Up to preserve     # heap property    shiftUp(size)   # Function to extract # the element with# most prioritydef extractMax() :         worldwide length    end result = H[0]           # Replace the choices value     # at the choices root with     # the ultimate leaf    H[0] = H[size]    length = size – 1           # Shift down the choices changed     # detail to hold the choices     # heap belongings    shiftDown(zero)    go back result   # Function to change the concern# of an elementdef changePriority(i,p) :     oldp = H[i]    H[i] = p           if (p > oldp) :             shiftUp(i)      else :             shiftDown(i)   # Function to get value of # the choices cutting-edge maximum elementdef getMax() :      go back H[0]   # Function to do away with the choices element# located at given indexdef Remove(i) :     H[i] = getMax() + 1           # Shift the choices node to the choices root    # of the choices heap    shiftUp(i)           # Extract the node    extractMax()   def change(i, j) :         temp = H[i]    H[i] = H[j]    H[j] = temp     # Insert the choices element to the # precedence queueinsert(45)insert(20)insert(14)insert(12)insert(31)insert(7)insert(11)insert(thirteen)insert(7)   i = 0   # Priority queue before extracting maxprint(“Priority Queue : “, end = “”)while (i <= size) :     print(H[i], cease = " ")    i += 1   print()   # Node with most priorityprint("Node with most precedence :" ,  extractMax())   # Priority queue after extracting maxprint("Priority queue after extracting most : ", stop = "")j = 0while (j <= length) :     print(H[j], quit = " ")    j += 1   print()   # Change the priority of element# present at index 2 to 49changePriority(2, 49)print("Priority queue after priority alternate : ", cease = "")ok = 0while (k <= length) :     print(H[k], stop = " ")    ok += 1   print()   # Remove element at index 3Remove(three)print("Priority queue after putting off the detail : ", stop = "")l = 0while (l 0 &&           H[parent(i)] < H[i])                     // Swap determine and present day node        swap(determine(i), i);             // Update i to figure of i        i = parent(i);     // Function to shift down the node in// order to maintain the heap propertystatic void shiftDown(int i)    int maxIndex = i;         // Left Child    int l = leftChild(i);         if (l H[maxIndex])            maxIndex = l;             // Right Child    int r = rightChild(i);         if (r H[maxIndex])            maxIndex = r;             // If i now not equal as maxIndex    if (i != maxIndex)            change(i, maxIndex);        shiftDown(maxIndex);     // Function to insert a// new detail in// the Binary Heapstatic void insert(int p)    length = size + 1;    H[size] = p;         // Shift Up to hold    // heap belongings    shiftUp(length); // Function to extract// the element with// most prioritystatic int extractMax()    int end result = H[0];         // Replace the cost    // at the root with    // the last leaf    H[0] = H[size];    length = length – 1;         // Shift down the replaced    // element to preserve the     // heap assets    shiftDown(0);    return result; // Function to exchange the priority// of an elementstatic void changePriority(int i,                           int p)    int oldp = H[i];    H[i] = p;         if (p > oldp)            shiftUp(i);        else            shiftDown(i);     // Function to get cost of// the modern most elementstatic int getMax()    return H[0]; // Function to do away with the choices detail// placed at given indexstatic void Remove(int i)    H[i] = getMax() + 1;         // Shift the choices node to the root    // of the heap    shiftUp(i);         // Extract the choices node    extractMax(); static void change(int i, int j)    int temp = H[i];    H[i] = H[j];    H[j] = temp; // Driver Codepublic static void Main(String[] args) /*              forty five            /                31      14          /      /         thirteen  20   7   11       /       12  7    Create a priority queue shown in    instance in a binary max heap form.    Queue will be represented within the    form of array as:    forty five 31 14 thirteen 20 7 11 12 7 */     // Insert the detail to the     // priority queue    insert(forty five);    insert(20);    insert(14);    insert(12);    insert(31);    insert(7);    insert(11);    insert(13);    insert(7);         int i = 0;         // Priority queue before extracting max    Console.Write(“Priority Queue : “);    whilst (i <= size)            Console.Write(H[i] + " ");        i++;             Console.Write("n");         // Node with maximum priority    Console.Write("Node with maximum precedence : " +                   extractMax() + "n");         // Priority queue after extracting max    Console.Write("Priority queue after " +                  "extracting maximum : ");    int j = zero;    at the same time as (j <= length)            Console.Write(H[j] + " ");        j++;             Console.Write("n");         // Change the concern of element    // gift at index 2 to 49    changePriority(2, forty nine);    Console.Write("Priority queue after " +                  "priority exchange : ");    int okay = 0;    whilst (okay <= size)            Console.Write(H[k] + " ");        k++;             Console.Write("n");         // Remove detail at index three    Remove(3);    Console.Write("Priority queue after " +                  "removing the element : ");    int l = zero;    at the same time as (l <= size)            Console.Write(H[l] + " ");        l++;     // This code is contributed by Amit KatiyarOutput: Priority Queue : forty five 31 14 thirteen 20 7 11 12 7  Node with maximum precedence : 45  Priority queue after extracting maximum : 31 20 14 13 7 7 11 12  Priority queue after precedence trade : 49 20 31 thirteen 7 7 11 12  Priority queue after removing the element : forty nine 20 31 12 7 7 11 Time Complexity: The time complexity of all of the operation is O(log N) except for GetMax() which has time complexity of O(1). Auxiliary Space: O(N) Attention reader! Don’t prevent studying now. Get preserve of all the crucial DSA principles with the DSA Self Paced Course at a scholar-pleasant charge and grow to be industry ready.  To entire your education from gaining knowledge of a language to DS Algo and lots of greater,  please refer Complete Interview Preparation Course.In case you wish to wait live classes with professionals, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.My Personal Notes arrow_drop_upSave

Shift Up Operation get node with 32 at the precise position: Swap the incorrectly placed node with its parent until the choices heap belongings is happy. For Example: As node 11 is much less than node 32 so, swap node 11 and node 32. Then, swap node 14 and node 32. And at remaining, swap node 31 and node 32.  ExtractMax: The maximum cost is stored at the choices root of the choices tree. But the choices root of the choices tree can not be at once removed. First, it’s miles changed with anyone of the choices leaves and then removed. For Example: To put off Node forty five, it is first replaced with node 11. But this violates the choices heap belongings, so move the replaced node down. For that, use shift down operation.  ShiftDown operation: Swap the choices incorrectly located node with a bigger toddler till the choices heap property is glad. For Example: Node eleven is swapped with node 32 then, with node 31 and in ultimate it’s far swapped with node 14.  ChangePriority: Let the choices changed element shift up or down relying on whether or not its priority reduced or expanded. For Example: Change the priority of nodes eleven to 35, due to this change the choices node has to shift up the choices node with the intention to preserve the heap assets.Remove: To put off an detail, exchange its priority to a cost larger than the choices current maximum, then shift it up, and then extract it the use of extract max. Find the choices modern-day maximum the usage of getMax.GetMax: The max fee is saved at the root of the tree. To getmax, just return the value at the root of the choices tree.Array Representation of Binary HeapSince the heap is maintained in shape of a whole binary tree, because of this fact the choices heap may be represented inside the form of an array. To keep the choices tree whole and shallow, even as inserting a brand new detail insert it within the leftmost vacant role within the ultimate degree i.e., at the choices give up of our array. Similarly, at the same time as extracting most update the root with the closing leaf at the choices final level i.e., the choices final detail of the array. Below is the choices instance of the choices equal:  Below is the application to implement Priority Queue the usage of Binary Heap:  C++ // C++ code to put into effect priority-queue// the usage of array implementation of// binary heap #encompass the use of namespace std; int H[50];int size = -1; // Function to go back the index of the // discern node of a given nodeint discern(int i)     return (i – 1) / 2; // Function to return the index of the // left child of the given nodeint leftChild(int i)     return ((2 * i) + 1); // Function to return the choices index of the choices// proper toddler of the given nodeint rightChild(int i)     return ((2 * i) + 2); // Function to shift up the node so as// to maintain the heap propertyvoid shiftUp(int i)    while (i > zero && H[parent(i)] < H[i])          // Swap discern and modern node        swap(H[parent(i)], H[i]);         // Update i to discern of i        i = determine(i);     // Function to shift down the choices node in// order to hold the choices heap propertyvoid shiftDown(int i)    int maxIndex = i;     // Left Child    int l = leftChild(i);     if (l H[maxIndex])         maxIndex = l;         // Right Child    int r = rightChild(i);     if (r H[maxIndex])         maxIndex = r;         // If i not identical as maxIndex    if (i != maxIndex)         swap(H[i], H[maxIndex]);        shiftDown(maxIndex);     // Function to insert a brand new element// in the Binary Heapvoid insert(int p)    size = length + 1;    H[size] = p;     // Shift Up to maintain heap belongings    shiftUp(length); // Function to extract the choices detail with// maximum priorityint extractMax()    int end result = H[0];     // Replace the choices cost at the choices root    // with the ultimate leaf    H[0] = H[size];    size = length – 1;     // Shift down the replaced detail    // to keep the heap assets    shiftDown(zero);    return end result; // Function to change the concern// of an elementvoid changePriority(int i, int p)    int oldp = H[i];    H[i] = p;     if (p > oldp)         shiftUp(i);        else         shiftDown(i);     // Function to get value of the choices cutting-edge// most elementint getMax()     go back H[0]; // Function to remove the detail// placed at given indexvoid eliminate(int i)    H[i] = getMax() + 1;     // Shift the choices node to the root    // of the heap    shiftUp(i);     // Extract the choices node    extractMax(); // Driver Codeint essential()     /*         forty five            /                 31      14          /      /           thirteen  20  7   eleven        /         12   7    Create a concern queue shown in    example in a binary max heap form.    Queue could be represented within the    shape of array as:    forty five 31 14 thirteen 20 7 eleven 12 7 */     // Insert the choices element to the choices    // precedence queue    insert(45);    insert(20);    insert(14);    insert(12);    insert(31);    insert(7);    insert(11);    insert(13);    insert(7);     int i = 0;     // Priority queue before extracting max    cout << "Priority Queue : ";    at the same time as (i <= size)         cout << H[i] << " ";        i++;         cout << "n";     // Node with most precedence    cout << "Node with maximum precedence : "         << extractMax() << "n";     // Priority queue after extracting max    cout << "Priority queue after "         << "extracting maximum : ";    int j = 0;    at the same time as (j <= size)         cout << H[j] << " ";        j++;         cout << "n";     // Change the concern of element    // present at index 2 to 49    changePriority(2, forty nine);    cout << "Priority queue after "         << "precedence trade : ";    int okay = 0;    whilst (okay <= length)         cout << H[k] << " ";        okay++;         cout << "n";     // Remove detail at index three    remove(three);    cout << "Priority queue after "         << "casting off the choices element : ";    int l = 0;    at the same time as (l <= size)         cout << H[l] < 0 &&         H[parent(i)] < H[i])      // Swap discern and present day node    switch(figure(i), i);     // Update i to parent of i    i = parent(i);   // Function to shift down the node in// order to maintain the heap propertystatic void shiftDown(int i)  int maxIndex = i;   // Left Child  int l = leftChild(i);   if (l H[maxIndex])      maxIndex = l;     // Right Child  int r = rightChild(i);   if (r H[maxIndex])      maxIndex = r;     // If i not equal as maxIndex  if (i != maxIndex)      swap(i, maxIndex);    shiftDown(maxIndex);   // Function to insert a// new detail in// the choices Binary Heapstatic void insert(int p)  length = length + 1;  H[size] = p;   // Shift Up to hold  // heap belongings  shiftUp(length); // Function to extract// the choices detail with// most prioritystatic int extractMax()  int end result = H[0];   // Replace the price  // at the root with  // the final leaf  H[0] = H[size];  length = length – 1;   // Shift down the choices changed  // element to maintain the choices  // heap property  shiftDown(0);  go back end result; // Function to alternate the concern// of an elementstatic void changePriority(int i,                           int p)  int oldp = H[i];  H[i] = p;   if (p > oldp)      shiftUp(i);    else      shiftDown(i);   // Function to get fee of// the choices modern most elementstatic int getMax()  go back H[0]; // Function to get rid of the element// located at given indexstatic void remove(int i)  H[i] = getMax() + 1;   // Shift the node to the root  // of the heap  shiftUp(i);   // Extract the node  extractMax();   static void switch(int i, int j)  int temp= H[i];  H[i] = H[j];  H[j] = temp; // Driver Codepublic static void important(String[] args)   /*           forty five            /                   31      14          /      /           13  20  7   eleven        /         12   7    Create a priority queue proven in    instance in a binary max heap shape.    Queue may be represented inside the    shape of array as:    45 31 14 13 20 7 11 12 7 */   // Insert the detail to the   // priority queue  insert(45);  insert(20);  insert(14);  insert(12);  insert(31);  insert(7);  insert(eleven);  insert(13);  insert(7);   int i = zero;   // Priority queue before extracting max  System.out.print(“Priority Queue : “);  while (i <= size)      System.out.print(H[i] + " ");    i++;     System.out.print("n");   // Node with most precedence  System.out.print("Node with most precedence : " +                    extractMax() + "n");   // Priority queue after extracting max  System.out.print("Priority queue after " +                   "extracting most : ");  int j = zero;  whilst (j <= length)      System.out.print(H[j] + " ");    j++;     System.out.print("n");   // Change the concern of element  // present at index 2 to forty nine  changePriority(2, 49);  System.out.print("Priority queue after " +                   "priority change : ");  int k = zero;  whilst (k <= length)      System.out.print(H[k] + " ");    okay++;     System.out.print("n");   // Remove element at index 3  do away with(three);  System.out.print("Priority queue after " +                   "getting rid of the detail : ");  int l = 0;  at the same time as (l zero and H[parent(i)] < H[i]) :                   # Swap discern and cutting-edge node        switch(discern(i), i)               # Update i to discern of i        i = discern(i)         # Function to shift down the choices node in# order to maintain the heap propertydef shiftDown(i) :     maxIndex = i           # Left Child    l = leftChild(i)           if (l H[maxIndex]) :             maxIndex = l           # Right Child    r = rightChild(i)           if (r H[maxIndex]) :             maxIndex = r           # If i now not identical as maxIndex    if (i != maxIndex) :             swap(i, maxIndex)        shiftDown(maxIndex)         # Function to insert a # new detail in # the Binary Heapdef insert(p) :         international length    length = length + 1    H[size] = p           # Shift Up to maintain     # heap belongings    shiftUp(length)   # Function to extract # the choices detail with# maximum prioritydef extractMax() :         global length    end result = H[0]           # Replace the cost     # at the root with     # the choices final leaf    H[0] = H[size]    length = size – 1           # Shift down the choices replaced     # element to maintain the choices     # heap belongings    shiftDown(zero)    go back result   # Function to alternate the concern# of an elementdef changePriority(i,p) :     oldp = H[i]    H[i] = p           if (p > oldp) :             shiftUp(i)      else :             shiftDown(i)   # Function to get cost of # the choices cutting-edge maximum elementdef getMax() :      return H[0]   # Function to remove the element# positioned at given indexdef Remove(i) :     H[i] = getMax() + 1           # Shift the choices node to the root    # of the choices heap    shiftUp(i)           # Extract the choices node    extractMax()   def change(i, j) :         temp = H[i]    H[i] = H[j]    H[j] = temp     # Insert the detail to the # precedence queueinsert(forty five)insert(20)insert(14)insert(12)insert(31)insert(7)insert(eleven)insert(13)insert(7)   i = 0   # Priority queue earlier than extracting maxprint(“Priority Queue : “, stop = “”)whilst (i <= size) :     print(H[i], stop = " ")    i += 1   print()   # Node with maximum priorityprint("Node with most precedence :" ,  extractMax())   # Priority queue after extracting maxprint("Priority queue after extracting maximum : ", cease = "")j = 0while (j <= length) :     print(H[j], quit = " ")    j += 1   print()   # Change the concern of element# present at index 2 to 49changePriority(2, 49)print("Priority queue after priority change : ", end = "")k = 0while (okay <= size) :     print(H[k], end = " ")    okay += 1   print()   # Remove element at index 3Remove(three)print("Priority queue after getting rid of the element : ", cease = "")l = 0while (l 0 &&           H[parent(i)] < H[i])                     // Swap discern and cutting-edge node        change(parent(i), i);             // Update i to discern of i        i = determine(i);     // Function to shift down the choices node in// order to preserve the heap propertystatic void shiftDown(int i)    int maxIndex = i;         // Left Child    int l = leftChild(i);         if (l H[maxIndex])            maxIndex = l;             // Right Child    int r = rightChild(i);         if (r H[maxIndex])            maxIndex = r;             // If i not equal as maxIndex    if (i != maxIndex)            change(i, maxIndex);        shiftDown(maxIndex);     // Function to insert a// new element in// the choices Binary Heapstatic void insert(int p)    size = size + 1;    H[size] = p;         // Shift Up to hold    // heap belongings    shiftUp(size); // Function to extract// the element with// maximum prioritystatic int extractMax()    int result = H[0];         // Replace the cost    // at the root with    // the last leaf    H[0] = H[size];    length = size – 1;         // Shift down the choices replaced    // element to keep the choices    // heap belongings    shiftDown(zero);    go back result; // Function to exchange the priority// of an elementstatic void changePriority(int i,                           int p)    int oldp = H[i];    H[i] = p;         if (p > oldp)            shiftUp(i);        else            shiftDown(i);     // Function to get fee of// the choices contemporary most elementstatic int getMax()    go back H[0]; // Function to put off the choices detail// positioned at given indexstatic void Remove(int i)    H[i] = getMax() + 1;         // Shift the choices node to the choices root    // of the heap    shiftUp(i);         // Extract the choices node    extractMax(); static void change(int i, int j)    int temp = H[i];    H[i] = H[j];    H[j] = temp; // Driver Codepublic static void Main(String[] args) /*              45            /                31      14          /      /         13  20   7   eleven       /       12  7    Create a concern queue proven in    example in a binary max heap form.    Queue may be represented in the    form of array as:    forty five 31 14 13 20 7 11 12 7 */     // Insert the choices detail to the     // priority queue    insert(forty five);    insert(20);    insert(14);    insert(12);    insert(31);    insert(7);    insert(eleven);    insert(thirteen);    insert(7);         int i = 0;         // Priority queue earlier than extracting max    Console.Write(“Priority Queue : “);    even as (i <= size)            Console.Write(H[i] + " ");        i++;             Console.Write("n");         // Node with maximum precedence    Console.Write("Node with maximum priority : " +                   extractMax() + "n");         // Priority queue after extracting max    Console.Write("Priority queue after " +                  "extracting most : ");    int j = 0;    at the same time as (j <= length)            Console.Write(H[j] + " ");        j++;             Console.Write("n");         // Change the concern of detail    // gift at index 2 to forty nine    changePriority(2, 49);    Console.Write("Priority queue after " +                  "priority change : ");    int okay = zero;    while (k <= size)            Console.Write(H[k] + " ");        okay++;             Console.Write("n");         // Remove element at index three    Remove(three);    Console.Write("Priority queue after " +                  "getting rid of the choices element : ");    int l = zero;    whilst (l <= length)            Console.Write(H[l] + " ");        l++;     // This code is contributed by using Amit KatiyarOutput: Priority Queue : forty five 31 14 13 20 7 11 12 7  Node with most precedence : forty five  Priority queue after extracting most : 31 20 14 13 7 7 eleven 12  Priority queue after precedence exchange : 49 20 31 thirteen 7 7 11 12  Priority queue after casting off the choices detail : forty nine 20 31 12 7 7 eleven Time Complexity: The time complexity of all of the operation is O(log N) besides for GetMax() which has time complexity of O(1). Auxiliary Space: O(N) Attention reader! Don’t stop studying now. Get keep of all of the essential DSA concepts with the DSA Self Paced Course at a pupil-pleasant price and emerge as industry equipped.  To entire your training from gaining knowledge of a language to DS Algo and plenty of more,  please refer Complete Interview Preparation Course.In case you want to attend stay instructions with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.My Personal Notes arrow_drop_upSave

ShiftDown operation: Swap the choices incorrectly placed node with a bigger infant until the choices heap belongings is satisfied. For Example: Node eleven is swapped with node 32 then, with node 31 and in ultimate it’s far swapped with node 14.  ChangePriority: Let the changed element shift up or down depending on whether its priority reduced or multiplied. For Example: Change the priority of nodes eleven to 35, due to this change the node has to shift up the node on the way to preserve the choices heap property.Remove: To do away with an detail, alternate its priority to a cost larger than the choices current most, then shift it up, and then extract it using extract max. Find the choices contemporary maximum the use of getMax.GetMax: The max price is saved at the choices root of the choices tree. To getmax, simply return the choices price at the choices root of the choices tree.Array Representation of Binary HeapSince the heap is maintained in shape of a entire binary tree, because of this reality the heap may be represented inside the shape of an array. To preserve the tree whole and shallow, whilst putting a new element insert it inside the leftmost vacant function inside the closing stage i.e., at the give up of our array. Similarly, while extracting most update the choices root with the choices closing leaf at the choices final stage i.e., the last element of the array. Below is the illustration of the equal:  Below is the choices software to implement Priority Queue using Binary Heap:  C++ // C++ code to put in force precedence-queue// using array implementation of// binary heap #consist of the use of namespace std; int H[50];int length = -1; // Function to go back the index of the // discern node of a given nodeint parent(int i)     go back (i – 1) / 2; // Function to return the index of the choices// left toddler of the choices given nodeint leftChild(int i)     go back ((2 * i) + 1); // Function to return the index of the // proper infant of the choices given nodeint rightChild(int i)     go back ((2 * i) + 2); // Function to shift up the node in order// to maintain the choices heap propertyvoid shiftUp(int i)    at the same time as (i > 0 && H[parent(i)] < H[i])          // Swap parent and contemporary node        change(H[parent(i)], H[i]);         // Update i to figure of i        i = determine(i);     // Function to shift down the choices node in// order to hold the heap propertyvoid shiftDown(int i)    int maxIndex = i;     // Left Child    int l = leftChild(i);     if (l H[maxIndex])         maxIndex = l;         // Right Child    int r = rightChild(i);     if (r H[maxIndex])         maxIndex = r;         // If i now not equal as maxIndex    if (i != maxIndex)         change(H[i], H[maxIndex]);        shiftDown(maxIndex);     // Function to insert a brand new element// within the Binary Heapvoid insert(int p)    length = size + 1;    H[size] = p;     // Shift Up to maintain heap belongings    shiftUp(length); // Function to extract the choices detail with// most priorityint extractMax()    int result = H[0];     // Replace the fee at the choices root    // with the remaining leaf    H[0] = H[size];    length = size – 1;     // Shift down the changed detail    // to hold the heap assets    shiftDown(0);    go back result; // Function to trade the concern// of an elementvoid changePriority(int i, int p)    int oldp = H[i];    H[i] = p;     if (p > oldp)         shiftUp(i);        else         shiftDown(i);     // Function to get price of the modern-day// most elementint getMax()     go back H[0]; // Function to dispose of the detail// positioned at given indexvoid put off(int i)    H[i] = getMax() + 1;     // Shift the choices node to the choices root    // of the choices heap    shiftUp(i);     // Extract the choices node    extractMax(); // Driver Codeint major()     /*         45            /                 31      14          /      /           thirteen  20  7   eleven        /         12   7    Create a priority queue shown in    example in a binary max heap form.    Queue can be represented within the    form of array as:    45 31 14 thirteen 20 7 11 12 7 */     // Insert the element to the     // priority queue    insert(45);    insert(20);    insert(14);    insert(12);    insert(31);    insert(7);    insert(11);    insert(thirteen);    insert(7);     int i = zero;     // Priority queue earlier than extracting max    cout << "Priority Queue : ";    while (i <= length)         cout << H[i] << " ";        i++;         cout << "n";     // Node with maximum priority    cout << "Node with maximum precedence : "         << extractMax() << "n";     // Priority queue after extracting max    cout << "Priority queue after "         << "extracting most : ";    int j = zero;    even as (j <= size)         cout << H[j] << " ";        j++;         cout << "n";     // Change the priority of element    // present at index 2 to 49    changePriority(2, forty nine);    cout << "Priority queue after "         << "precedence alternate : ";    int okay = 0;    whilst (okay <= length)         cout << H[k] << " ";        k++;         cout << "n";     // Remove element at index 3    cast off(three);    cout << "Priority queue after "         << "getting rid of the detail : ";    int l = zero;    even as (l <= length)         cout << H[l] < zero &&         H[parent(i)] < H[i])      // Swap determine and contemporary node    swap(figure(i), i);     // Update i to figure of i    i = parent(i);   // Function to shift down the choices node in// order to maintain the choices heap propertystatic void shiftDown(int i)  int maxIndex = i;   // Left Child  int l = leftChild(i);   if (l H[maxIndex])      maxIndex = l;     // Right Child  int r = rightChild(i);   if (r H[maxIndex])      maxIndex = r;     // If i no longer same as maxIndex  if (i != maxIndex)      swap(i, maxIndex);    shiftDown(maxIndex);   // Function to insert a// new element in// the Binary Heapstatic void insert(int p)  size = size + 1;  H[size] = p;   // Shift Up to hold  // heap property  shiftUp(length); // Function to extract// the choices element with// maximum prioritystatic int extractMax()  int result = H[0];   // Replace the choices fee  // at the choices root with  // the choices remaining leaf  H[0] = H[size];  size = size – 1;   // Shift down the choices replaced  // detail to preserve the choices  // heap belongings  shiftDown(0);  go back result; // Function to change the concern// of an elementstatic void changePriority(int i,                           int p)  int oldp = H[i];  H[i] = p;   if (p > oldp)      shiftUp(i);    else      shiftDown(i);   // Function to get fee of// the choices current maximum elementstatic int getMax()  return H[0]; // Function to take away the choices element// located at given indexstatic void remove(int i)  H[i] = getMax() + 1;   // Shift the choices node to the choices root  // of the choices heap  shiftUp(i);   // Extract the node  extractMax();   static void change(int i, int j)  int temp= H[i];  H[i] = H[j];  H[j] = temp; // Driver Codepublic static void important(String[] args)   /*           forty five            /                   31      14          /      /           thirteen  20  7   eleven        /         12   7    Create a priority queue proven in    example in a binary max heap form.    Queue might be represented in the    form of array as:    45 31 14 thirteen 20 7 11 12 7 */   // Insert the element to the choices  // precedence queue  insert(forty five);  insert(20);  insert(14);  insert(12);  insert(31);  insert(7);  insert(11);  insert(13);  insert(7);   int i = zero;   // Priority queue earlier than extracting max  System.out.print(“Priority Queue : “);  at the same time as (i <= size)      System.out.print(H[i] + " ");    i++;     System.out.print("n");   // Node with most precedence  System.out.print("Node with maximum priority : " +                    extractMax() + "n");   // Priority queue after extracting max  System.out.print("Priority queue after " +                   "extracting maximum : ");  int j = zero;  even as (j <= size)      System.out.print(H[j] + " ");    j++;     System.out.print("n");   // Change the concern of element  // gift at index 2 to 49  changePriority(2, 49);  System.out.print("Priority queue after " +                   "precedence change : ");  int k = zero;  while (k <= length)      System.out.print(H[k] + " ");    okay++;     System.out.print("n");   // Remove detail at index three  cast off(3);  System.out.print("Priority queue after " +                   "putting off the element : ");  int l = 0;  while (l 0 and H[parent(i)] < H[i]) :                   # Swap figure and modern-day node        swap(determine(i), i)               # Update i to discern of i        i = determine(i)         # Function to shift down the choices node in# order to keep the heap propertydef shiftDown(i) :     maxIndex = i           # Left Child    l = leftChild(i)           if (l H[maxIndex]) :             maxIndex = l           # Right Child    r = rightChild(i)           if (r H[maxIndex]) :             maxIndex = r           # If i no longer identical as maxIndex    if (i != maxIndex) :             swap(i, maxIndex)        shiftDown(maxIndex)         # Function to insert a # new detail in # the Binary Heapdef insert(p) :         worldwide size    length = length + 1    H[size] = p           # Shift Up to hold     # heap property    shiftUp(length)   # Function to extract # the detail with# maximum prioritydef extractMax() :         international size    end result = H[0]           # Replace the choices fee     # at the choices root with     # the choices final leaf    H[0] = H[size]    size = size – 1           # Shift down the replaced     # element to hold the choices     # heap assets    shiftDown(0)    go back result   # Function to alternate the concern# of an elementdef changePriority(i,p) :     oldp = H[i]    H[i] = p           if (p > oldp) :             shiftUp(i)      else :             shiftDown(i)   # Function to get fee of # the current most elementdef getMax() :      go back H[0]   # Function to remove the choices detail# located at given indexdef Remove(i) :     H[i] = getMax() + 1           # Shift the choices node to the root    # of the heap    shiftUp(i)           # Extract the choices node    extractMax()   def switch(i, j) :         temp = H[i]    H[i] = H[j]    H[j] = temp     # Insert the choices element to the # priority queueinsert(45)insert(20)insert(14)insert(12)insert(31)insert(7)insert(eleven)insert(13)insert(7)   i = 0   # Priority queue before extracting maxprint(“Priority Queue : “, end = “”)whilst (i <= length) :     print(H[i], end = " ")    i += 1   print()   # Node with most priorityprint("Node with maximum precedence :" ,  extractMax())   # Priority queue after extracting maxprint("Priority queue after extracting most : ", quit = "")j = 0while (j <= size) :     print(H[j], give up = " ")    j += 1   print()   # Change the priority of detail# present at index 2 to 49changePriority(2, forty nine)print("Priority queue after priority alternate : ", give up = "")k = 0while (okay <= length) :     print(H[k], end = " ")    k += 1   print()   # Remove element at index 3Remove(3)print("Priority queue after getting rid of the element : ", stop = "")l = 0while (l zero &&           H[parent(i)] < H[i])                     // Swap determine and current node        switch(discern(i), i);             // Update i to figure of i        i = figure(i);     // Function to shift down the choices node in// order to maintain the choices heap propertystatic void shiftDown(int i)    int maxIndex = i;         // Left Child    int l = leftChild(i);         if (l H[maxIndex])            maxIndex = l;             // Right Child    int r = rightChild(i);         if (r H[maxIndex])            maxIndex = r;             // If i now not identical as maxIndex    if (i != maxIndex)            change(i, maxIndex);        shiftDown(maxIndex);     // Function to insert a// new element in// the Binary Heapstatic void insert(int p)    length = size + 1;    H[size] = p;         // Shift Up to preserve    // heap property    shiftUp(size); // Function to extract// the detail with// maximum prioritystatic int extractMax()    int end result = H[0];         // Replace the choices price    // at the choices root with    // the choices final leaf    H[0] = H[size];    length = size – 1;         // Shift down the replaced    // detail to preserve the choices    // heap belongings    shiftDown(zero);    go back result; // Function to trade the priority// of an elementstatic void changePriority(int i,                           int p)    int oldp = H[i];    H[i] = p;         if (p > oldp)            shiftUp(i);        else            shiftDown(i);     // Function to get cost of// the cutting-edge most elementstatic int getMax()    return H[0]; // Function to get rid of the element// placed at given indexstatic void Remove(int i)    H[i] = getMax() + 1;         // Shift the choices node to the root    // of the heap    shiftUp(i);         // Extract the choices node    extractMax(); static void swap(int i, int j)    int temp = H[i];    H[i] = H[j];    H[j] = temp; // Driver Codepublic static void Main(String[] args) /*              forty five            /                31      14          /      /         13  20   7   eleven       /       12  7    Create a priority queue shown in    example in a binary max heap shape.    Queue will be represented within the    form of array as:    forty five 31 14 thirteen 20 7 eleven 12 7 */     // Insert the element to the     // precedence queue    insert(forty five);    insert(20);    insert(14);    insert(12);    insert(31);    insert(7);    insert(eleven);    insert(13);    insert(7);         int i = 0;         // Priority queue earlier than extracting max    Console.Write(“Priority Queue : “);    while (i <= length)            Console.Write(H[i] + " ");        i++;             Console.Write("n");         // Node with most priority    Console.Write("Node with most precedence : " +                   extractMax() + "n");         // Priority queue after extracting max    Console.Write("Priority queue after " +                  "extracting most : ");    int j = 0;    even as (j <= size)            Console.Write(H[j] + " ");        j++;             Console.Write("n");         // Change the priority of detail    // present at index 2 to 49    changePriority(2, 49);    Console.Write("Priority queue after " +                  "priority trade : ");    int k = zero;    even as (k <= size)            Console.Write(H[k] + " ");        okay++;             Console.Write("n");         // Remove detail at index three    Remove(3);    Console.Write("Priority queue after " +                  "doing away with the detail : ");    int l = zero;    while (l <= size)            Console.Write(H[l] + " ");        l++;     // This code is contributed by means of Amit KatiyarOutput: Priority Queue : 45 31 14 thirteen 20 7 eleven 12 7  Node with most precedence : 45  Priority queue after extracting maximum : 31 20 14 13 7 7 eleven 12  Priority queue after priority alternate : forty nine 20 31 thirteen 7 7 eleven 12  Priority queue after casting off the detail : 49 20 31 12 7 7 eleven Time Complexity: The time complexity of all the operation is O(log N) except for GetMax() which has time complexity of O(1). Auxiliary Space: O(N) Attention reader! Don’t stop gaining knowledge of now. Get hold of all the vital DSA standards with the DSA Self Paced Course at a student-friendly price and emerge as industry prepared.  To whole your practise from studying a language to DS Algo and plenty of extra,  please refer Complete Interview Preparation Course.In case you want to attend live lessons with specialists, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.My Personal Notes arrow_drop_upSave

ChangePriority: Let the modified detail shift up or down depending on whether its precedence decreased or extended. For Example: Change the priority of nodes 11 to 35, because of this variation the choices node has to shift up the node on the way to maintain the choices heap belongings.Remove: To eliminate an element, change its precedence to a fee large than the current maximum, then shift it up, after which extract it the use of extract max. Find the cutting-edge most using getMax.GetMax: The max price is stored at the root of the choices tree. To getmax, simply return the value at the choices root of the tree.Array Representation of Binary HeapSince the choices heap is maintained in form of a complete binary tree, due to this fact the heap can be represented in the form of an array. To maintain the tree entire and shallow, at the same time as inserting a brand new detail insert it inside the leftmost vacant function inside the remaining level i.e., at the choices cease of our array. Similarly, even as extracting maximum update the root with the choices final leaf at the last degree i.e., the choices closing detail of the choices array. Below is the illustration of the same:  Below is the program to put into effect Priority Queue using Binary Heap:  C++ // C++ code to enforce priority-queue// using array implementation of// binary heap #include using namespace std; int H[50];int size = -1; // Function to return the choices index of the choices// determine node of a given nodeint figure(int i)     return (i – 1) / 2; // Function to go back the index of the // left infant of the choices given nodeint leftChild(int i)     go back ((2 * i) + 1); // Function to go back the index of the // right child of the choices given nodeint rightChild(int i)     go back ((2 * i) + 2); // Function to shift up the node so as// to hold the heap propertyvoid shiftUp(int i)    even as (i > zero && H[parent(i)] < H[i])          // Swap determine and present day node        change(H[parent(i)], H[i]);         // Update i to determine of i        i = determine(i);     // Function to shift down the node in// order to maintain the heap propertyvoid shiftDown(int i)    int maxIndex = i;     // Left Child    int l = leftChild(i);     if (l H[maxIndex])         maxIndex = l;         // Right Child    int r = rightChild(i);     if (r H[maxIndex])         maxIndex = r;         // If i no longer equal as maxIndex    if (i != maxIndex)         swap(H[i], H[maxIndex]);        shiftDown(maxIndex);     // Function to insert a new element// in the Binary Heapvoid insert(int p)    size = length + 1;    H[size] = p;     // Shift Up to keep heap assets    shiftUp(size); // Function to extract the choices detail with// most priorityint extractMax()    int end result = H[0];     // Replace the choices value at the root    // with the choices final leaf    H[0] = H[size];    length = size – 1;     // Shift down the changed element    // to maintain the heap assets    shiftDown(0);    return end result; // Function to trade the concern// of an elementvoid changePriority(int i, int p)    int oldp = H[i];    H[i] = p;     if (p > oldp)         shiftUp(i);        else         shiftDown(i);     // Function to get fee of the choices contemporary// maximum elementint getMax()     return H[0]; // Function to take away the detail// placed at given indexvoid remove(int i)    H[i] = getMax() + 1;     // Shift the node to the choices root    // of the heap    shiftUp(i);     // Extract the node    extractMax(); // Driver Codeint principal()     /*         forty five            /                 31      14          /      /           thirteen  20  7   11        /         12   7    Create a priority queue proven in    instance in a binary max heap form.    Queue might be represented in the    shape of array as:    forty five 31 14 13 20 7 eleven 12 7 */     // Insert the choices detail to the     // precedence queue    insert(45);    insert(20);    insert(14);    insert(12);    insert(31);    insert(7);    insert(eleven);    insert(13);    insert(7);     int i = zero;     // Priority queue earlier than extracting max    cout << "Priority Queue : ";    whilst (i <= length)         cout << H[i] << " ";        i++;         cout << "n";     // Node with most precedence    cout << "Node with most precedence : "         << extractMax() << "n";     // Priority queue after extracting max    cout << "Priority queue after "         << "extracting maximum : ";    int j = 0;    whilst (j <= length)         cout << H[j] << " ";        j++;         cout << "n";     // Change the priority of element    // present at index 2 to 49    changePriority(2, forty nine);    cout << "Priority queue after "         << "precedence alternate : ";    int k = zero;    while (ok <= size)         cout << H[k] << " ";        okay++;         cout << "n";     // Remove element at index 3    cast off(3);    cout << "Priority queue after "         << "putting off the detail : ";    int l = zero;    at the same time as (l <= length)         cout << H[l] < zero &&         H[parent(i)] < H[i])      // Swap figure and modern node    change(discern(i), i);     // Update i to parent of i    i = determine(i);   // Function to shift down the choices node in// order to hold the choices heap propertystatic void shiftDown(int i)  int maxIndex = i;   // Left Child  int l = leftChild(i);   if (l H[maxIndex])      maxIndex = l;     // Right Child  int r = rightChild(i);   if (r H[maxIndex])      maxIndex = r;     // If i no longer identical as maxIndex  if (i != maxIndex)      switch(i, maxIndex);    shiftDown(maxIndex);   // Function to insert a// new element in// the Binary Heapstatic void insert(int p)  length = size + 1;  H[size] = p;   // Shift Up to maintain  // heap assets  shiftUp(length); // Function to extract// the detail with// most prioritystatic int extractMax()  int end result = H[0];   // Replace the value  // at the choices root with  // the choices closing leaf  H[0] = H[size];  length = length – 1;   // Shift down the changed  // element to maintain the   // heap belongings  shiftDown(0);  return result; // Function to exchange the priority// of an elementstatic void changePriority(int i,                           int p)  int oldp = H[i];  H[i] = p;   if (p > oldp)      shiftUp(i);    else      shiftDown(i);   // Function to get fee of// the modern maximum elementstatic int getMax()  return H[0]; // Function to remove the choices detail// placed at given indexstatic void take away(int i)  H[i] = getMax() + 1;   // Shift the node to the choices root  // of the choices heap  shiftUp(i);   // Extract the node  extractMax();   static void swap(int i, int j)  int temp= H[i];  H[i] = H[j];  H[j] = temp; // Driver Codepublic static void principal(String[] args)   /*           forty five            /                   31      14          /      /           thirteen  20  7   11        /         12   7    Create a priority queue shown in    instance in a binary max heap shape.    Queue could be represented in the    form of array as:    forty five 31 14 thirteen 20 7 eleven 12 7 */   // Insert the detail to the   // priority queue  insert(forty five);  insert(20);  insert(14);  insert(12);  insert(31);  insert(7);  insert(11);  insert(13);  insert(7);   int i = zero;   // Priority queue before extracting max  System.out.print(“Priority Queue : “);  while (i <= size)      System.out.print(H[i] + " ");    i++;     System.out.print("n");   // Node with most priority  System.out.print("Node with maximum priority : " +                    extractMax() + "n");   // Priority queue after extracting max  System.out.print("Priority queue after " +                   "extracting most : ");  int j = zero;  even as (j <= length)      System.out.print(H[j] + " ");    j++;     System.out.print("n");   // Change the priority of element  // present at index 2 to forty nine  changePriority(2, forty nine);  System.out.print("Priority queue after " +                   "precedence alternate : ");  int k = zero;  whilst (ok <= size)      System.out.print(H[k] + " ");    okay++;     System.out.print("n");   // Remove detail at index three  remove(three);  System.out.print("Priority queue after " +                   "putting off the element : ");  int l = zero;  at the same time as (l zero and H[parent(i)] < H[i]) :                   # Swap figure and cutting-edge node        switch(figure(i), i)               # Update i to parent of i        i = parent(i)         # Function to shift down the node in# order to keep the heap propertydef shiftDown(i) :     maxIndex = i           # Left Child    l = leftChild(i)           if (l H[maxIndex]) :             maxIndex = l           # Right Child    r = rightChild(i)           if (r H[maxIndex]) :             maxIndex = r           # If i now not identical as maxIndex    if (i != maxIndex) :             change(i, maxIndex)        shiftDown(maxIndex)         # Function to insert a # new detail in # the Binary Heapdef insert(p) :         worldwide size    length = length + 1    H[size] = p           # Shift Up to hold     # heap belongings    shiftUp(size)   # Function to extract # the element with# most prioritydef extractMax() :         global length    result = H[0]           # Replace the cost     # at the root with     # the choices closing leaf    H[0] = H[size]    length = length – 1           # Shift down the replaced     # detail to keep the choices     # heap assets    shiftDown(0)    return end result   # Function to change the priority# of an elementdef changePriority(i,p) :     oldp = H[i]    H[i] = p           if (p > oldp) :             shiftUp(i)      else :             shiftDown(i)   # Function to get value of # the modern-day maximum elementdef getMax() :      go back H[0]   # Function to put off the element# placed at given indexdef Remove(i) :     H[i] = getMax() + 1           # Shift the choices node to the choices root    # of the heap    shiftUp(i)           # Extract the node    extractMax()   def switch(i, j) :         temp = H[i]    H[i] = H[j]    H[j] = temp     # Insert the element to the choices# priority queueinsert(forty five)insert(20)insert(14)insert(12)insert(31)insert(7)insert(11)insert(13)insert(7)   i = zero   # Priority queue before extracting maxprint(“Priority Queue : “, cease = “”)whilst (i <= size) :     print(H[i], cease = " ")    i += 1   print()   # Node with most priorityprint("Node with maximum priority :" ,  extractMax())   # Priority queue after extracting maxprint("Priority queue after extracting most : ", quit = "")j = 0while (j <= length) :     print(H[j], cease = " ")    j += 1   print()   # Change the concern of element# gift at index 2 to 49changePriority(2, forty nine)print("Priority queue after priority alternate : ", cease = "")ok = 0while (okay <= length) :     print(H[k], stop = " ")    k += 1   print()   # Remove detail at index 3Remove(three)print("Priority queue after doing away with the element : ", stop = "")l = 0while (l zero &&           H[parent(i)] < H[i])                     // Swap determine and present day node        switch(parent(i), i);             // Update i to discern of i        i = parent(i);     // Function to shift down the choices node in// order to maintain the heap propertystatic void shiftDown(int i)    int maxIndex = i;         // Left Child    int l = leftChild(i);         if (l H[maxIndex])            maxIndex = l;             // Right Child    int r = rightChild(i);         if (r H[maxIndex])            maxIndex = r;             // If i not equal as maxIndex    if (i != maxIndex)            switch(i, maxIndex);        shiftDown(maxIndex);     // Function to insert a// new detail in// the Binary Heapstatic void insert(int p)    size = size + 1;    H[size] = p;         // Shift Up to keep    // heap assets    shiftUp(length); // Function to extract// the choices detail with// maximum prioritystatic int extractMax()    int result = H[0];         // Replace the choices value    // at the root with    // the choices last leaf    H[0] = H[size];    size = length – 1;         // Shift down the choices replaced    // element to hold the choices    // heap belongings    shiftDown(zero);    return end result; // Function to change the priority// of an elementstatic void changePriority(int i,                           int p)    int oldp = H[i];    H[i] = p;         if (p > oldp)            shiftUp(i);        else            shiftDown(i);     // Function to get price of// the choices contemporary maximum elementstatic int getMax()    return H[0]; // Function to put off the choices detail// located at given indexstatic void Remove(int i)    H[i] = getMax() + 1;         // Shift the node to the root    // of the choices heap    shiftUp(i);         // Extract the node    extractMax(); static void change(int i, int j)    int temp = H[i];    H[i] = H[j];    H[j] = temp; // Driver Codepublic static void Main(String[] args) /*              forty five            /                31      14          /      /         thirteen  20   7   eleven       /       12  7    Create a priority queue shown in    instance in a binary max heap shape.    Queue can be represented in the    form of array as:    45 31 14 13 20 7 eleven 12 7 */     // Insert the choices detail to the choices    // priority queue    insert(forty five);    insert(20);    insert(14);    insert(12);    insert(31);    insert(7);    insert(eleven);    insert(13);    insert(7);         int i = 0;         // Priority queue earlier than extracting max    Console.Write(“Priority Queue : “);    at the same time as (i <= length)            Console.Write(H[i] + " ");        i++;             Console.Write("n");         // Node with most priority    Console.Write("Node with most priority : " +                   extractMax() + "n");         // Priority queue after extracting max    Console.Write("Priority queue after " +                  "extracting most : ");    int j = 0;    even as (j <= length)            Console.Write(H[j] + " ");        j++;             Console.Write("n");         // Change the concern of element    // gift at index 2 to 49    changePriority(2, 49);    Console.Write("Priority queue after " +                  "priority change : ");    int ok = zero;    even as (k <= length)            Console.Write(H[k] + " ");        okay++;             Console.Write("n");         // Remove element at index 3    Remove(three);    Console.Write("Priority queue after " +                  "casting off the choices detail : ");    int l = zero;    even as (l <= length)            Console.Write(H[l] + " ");        l++;     // This code is contributed by Amit KatiyarOutput: Priority Queue : 45 31 14 thirteen 20 7 eleven 12 7  Node with most priority : 45  Priority queue after extracting most : 31 20 14 13 7 7 11 12  Priority queue after precedence change : forty nine 20 31 thirteen 7 7 11 12  Priority queue after eliminating the choices element : forty nine 20 31 12 7 7 eleven Time Complexity: The time complexity of all the operation is O(log N) except for GetMax() which has time complexity of O(1). Auxiliary Space: O(N) Attention reader! Don’t prevent gaining knowledge of now. Get maintain of all the critical DSA principles with the DSA Self Paced Course at a scholar-friendly charge and grow to be enterprise geared up.  To complete your practise from studying a language to DS Algo and many more,  please refer Complete Interview Preparation Course.In case you desire to attend stay lessons with specialists, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.My Personal Notes arrow_drop_upSave

Since the choices heap is maintained in form of a complete binary tree, due to this fact the choices heap can be represented inside the form of an array. To keep the choices tree entire and shallow, at the same time as inserting a new element insert it in the leftmost vacant role in the last stage i.e., at the give up of our array. Similarly, at the same time as extracting most update the choices root with the choices final leaf at the last level i.e., the choices remaining detail of the array. Below is the choices illustration of the choices equal:  Below is the program to put into effect Priority Queue using Binary Heap:  C++ // C++ code to enforce priority-queue// using array implementation of// binary heap #encompass the usage of namespace std; int H[50];int size = -1; // Function to go back the choices index of the // parent node of a given nodeint determine(int i)     go back (i – 1) / 2; // Function to go back the index of the // left child of the given nodeint leftChild(int i)     return ((2 * i) + 1); // Function to return the index of the // proper child of the given nodeint rightChild(int i)     go back ((2 * i) + 2); // Function to shift up the choices node in order// to maintain the choices heap propertyvoid shiftUp(int i)    whilst (i > 0 && H[parent(i)] < H[i])          // Swap determine and modern node        swap(H[parent(i)], H[i]);         // Update i to parent of i        i = figure(i);     // Function to shift down the node in// order to hold the choices heap propertyvoid shiftDown(int i)    int maxIndex = i;     // Left Child    int l = leftChild(i);     if (l H[maxIndex])         maxIndex = l;         // Right Child    int r = rightChild(i);     if (r H[maxIndex])         maxIndex = r;         // If i not equal as maxIndex    if (i != maxIndex)         change(H[i], H[maxIndex]);        shiftDown(maxIndex);     // Function to insert a new detail// in the Binary Heapvoid insert(int p)    size = size + 1;    H[size] = p;     // Shift Up to hold heap assets    shiftUp(size); // Function to extract the element with// maximum priorityint extractMax()    int end result = H[0];     // Replace the choices price at the root    // with the choices remaining leaf    H[0] = H[size];    size = size – 1;     // Shift down the replaced element    // to maintain the choices heap assets    shiftDown(zero);    return end result; // Function to exchange the priority// of an elementvoid changePriority(int i, int p)    int oldp = H[i];    H[i] = p;     if (p > oldp)         shiftUp(i);        else         shiftDown(i);     // Function to get value of the choices cutting-edge// most elementint getMax()     go back H[0]; // Function to do away with the detail// positioned at given indexvoid cast off(int i)    H[i] = getMax() + 1;     // Shift the choices node to the root    // of the choices heap    shiftUp(i);     // Extract the node    extractMax(); // Driver Codeint essential()     /*         forty five            /                 31      14          /      /           thirteen  20  7   eleven        /         12   7    Create a concern queue shown in    instance in a binary max heap shape.    Queue can be represented inside the    form of array as:    45 31 14 thirteen 20 7 eleven 12 7 */     // Insert the detail to the     // priority queue    insert(forty five);    insert(20);    insert(14);    insert(12);    insert(31);    insert(7);    insert(eleven);    insert(13);    insert(7);     int i = zero;     // Priority queue before extracting max    cout << "Priority Queue : ";    while (i <= size)         cout << H[i] << " ";        i++;         cout << "n";     // Node with most precedence    cout << "Node with most priority : "         << extractMax() << "n";     // Priority queue after extracting max    cout << "Priority queue after "         << "extracting most : ";    int j = 0;    whilst (j <= size)         cout << H[j] << " ";        j++;         cout << "n";     // Change the concern of element    // gift at index 2 to forty nine    changePriority(2, 49);    cout << "Priority queue after "         << "priority trade : ";    int okay = zero;    while (ok <= length)         cout << H[k] << " ";        k++;         cout << "n";     // Remove detail at index three    get rid of(3);    cout << "Priority queue after "         << "putting off the choices detail : ";    int l = 0;    while (l <= length)         cout << H[l] < 0 &&         H[parent(i)] < H[i])      // Swap discern and current node    swap(discern(i), i);     // Update i to parent of i    i = determine(i);   // Function to shift down the choices node in// order to preserve the choices heap propertystatic void shiftDown(int i)  int maxIndex = i;   // Left Child  int l = leftChild(i);   if (l H[maxIndex])      maxIndex = l;     // Right Child  int r = rightChild(i);   if (r H[maxIndex])      maxIndex = r;     // If i no longer same as maxIndex  if (i != maxIndex)      swap(i, maxIndex);    shiftDown(maxIndex);   // Function to insert a// new detail in// the choices Binary Heapstatic void insert(int p)  length = length + 1;  H[size] = p;   // Shift Up to maintain  // heap property  shiftUp(length); // Function to extract// the element with// maximum prioritystatic int extractMax()  int result = H[0];   // Replace the choices fee  // at the choices root with  // the last leaf  H[0] = H[size];  length = size – 1;   // Shift down the choices changed  // detail to hold the   // heap belongings  shiftDown(zero);  go back result; // Function to exchange the concern// of an elementstatic void changePriority(int i,                           int p)  int oldp = H[i];  H[i] = p;   if (p > oldp)      shiftUp(i);    else      shiftDown(i);   // Function to get price of// the choices contemporary maximum elementstatic int getMax()  return H[0]; // Function to put off the choices element// positioned at given indexstatic void get rid of(int i)  H[i] = getMax() + 1;   // Shift the choices node to the root  // of the heap  shiftUp(i);   // Extract the choices node  extractMax();   static void switch(int i, int j)  int temp= H[i];  H[i] = H[j];  H[j] = temp; // Driver Codepublic static void foremost(String[] args)   /*           45            /                   31      14          /      /           thirteen  20  7   11        /         12   7    Create a priority queue shown in    instance in a binary max heap form.    Queue can be represented in the    form of array as:    45 31 14 13 20 7 11 12 7 */   // Insert the choices detail to the choices  // precedence queue  insert(45);  insert(20);  insert(14);  insert(12);  insert(31);  insert(7);  insert(11);  insert(thirteen);  insert(7);   int i = zero;   // Priority queue earlier than extracting max  System.out.print(“Priority Queue : “);  even as (i <= size)      System.out.print(H[i] + " ");    i++;     System.out.print("n");   // Node with most precedence  System.out.print("Node with maximum priority : " +                    extractMax() + "n");   // Priority queue after extracting max  System.out.print("Priority queue after " +                   "extracting maximum : ");  int j = zero;  at the same time as (j <= size)      System.out.print(H[j] + " ");    j++;     System.out.print("n");   // Change the priority of detail  // gift at index 2 to 49  changePriority(2, 49);  System.out.print("Priority queue after " +                   "precedence change : ");  int okay = 0;  whilst (k <= length)      System.out.print(H[k] + " ");    k++;     System.out.print("n");   // Remove detail at index three  cast off(three);  System.out.print("Priority queue after " +                   "doing away with the choices element : ");  int l = 0;  while (l zero and H[parent(i)] < H[i]) :                   # Swap discern and present day node        change(figure(i), i)               # Update i to determine of i        i = determine(i)         # Function to shift down the node in# order to hold the heap propertydef shiftDown(i) :     maxIndex = i           # Left Child    l = leftChild(i)           if (l H[maxIndex]) :             maxIndex = l           # Right Child    r = rightChild(i)           if (r H[maxIndex]) :             maxIndex = r           # If i not identical as maxIndex    if (i != maxIndex) :             change(i, maxIndex)        shiftDown(maxIndex)         # Function to insert a # new element in # the choices Binary Heapdef insert(p) :         worldwide length    length = size + 1    H[size] = p           # Shift Up to preserve     # heap assets    shiftUp(length)   # Function to extract # the element with# most prioritydef extractMax() :         worldwide size    result = H[0]           # Replace the choices fee     # at the choices root with     # the choices ultimate leaf    H[0] = H[size]    length = size – 1           # Shift down the choices replaced     # detail to keep the      # heap belongings    shiftDown(zero)    go back result   # Function to change the priority# of an elementdef changePriority(i,p) :     oldp = H[i]    H[i] = p           if (p > oldp) :             shiftUp(i)      else :             shiftDown(i)   # Function to get fee of # the choices present day most elementdef getMax() :      go back H[0]   # Function to do away with the choices detail# placed at given indexdef Remove(i) :     H[i] = getMax() + 1           # Shift the node to the root    # of the heap    shiftUp(i)           # Extract the node    extractMax()   def swap(i, j) :         temp = H[i]    H[i] = H[j]    H[j] = temp     # Insert the choices element to the # priority queueinsert(forty five)insert(20)insert(14)insert(12)insert(31)insert(7)insert(eleven)insert(13)insert(7)   i = 0   # Priority queue before extracting maxprint(“Priority Queue : “, stop = “”)even as (i <= size) :     print(H[i], stop = " ")    i += 1   print()   # Node with most priorityprint("Node with most priority :" ,  extractMax())   # Priority queue after extracting maxprint("Priority queue after extracting maximum : ", end = "")j = 0while (j <= size) :     print(H[j], cease = " ")    j += 1   print()   # Change the priority of element# present at index 2 to 49changePriority(2, 49)print("Priority queue after priority alternate : ", give up = "")k = 0while (k <= length) :     print(H[k], cease = " ")    k += 1   print()   # Remove element at index 3Remove(three)print("Priority queue after eliminating the choices detail : ", stop = "")l = 0while (l 0 &&           H[parent(i)] < H[i])                     // Swap determine and contemporary node        change(determine(i), i);             // Update i to figure of i        i = parent(i);     // Function to shift down the node in// order to maintain the choices heap propertystatic void shiftDown(int i)    int maxIndex = i;         // Left Child    int l = leftChild(i);         if (l H[maxIndex])            maxIndex = l;             // Right Child    int r = rightChild(i);         if (r H[maxIndex])            maxIndex = r;             // If i not identical as maxIndex    if (i != maxIndex)            change(i, maxIndex);        shiftDown(maxIndex);     // Function to insert a// new element in// the choices Binary Heapstatic void insert(int p)    length = size + 1;    H[size] = p;         // Shift Up to preserve    // heap belongings    shiftUp(size); // Function to extract// the detail with// maximum prioritystatic int extractMax()    int end result = H[0];         // Replace the choices cost    // at the root with    // the choices final leaf    H[0] = H[size];    length = length – 1;         // Shift down the choices changed    // detail to preserve the choices    // heap assets    shiftDown(0);    return end result; // Function to alternate the priority// of an elementstatic void changePriority(int i,                           int p)    int oldp = H[i];    H[i] = p;         if (p > oldp)            shiftUp(i);        else            shiftDown(i);     // Function to get price of// the choices modern-day most elementstatic int getMax()    go back H[0]; // Function to eliminate the detail// placed at given indexstatic void Remove(int i)    H[i] = getMax() + 1;         // Shift the node to the root    // of the choices heap    shiftUp(i);         // Extract the choices node    extractMax(); static void change(int i, int j)    int temp = H[i];    H[i] = H[j];    H[j] = temp; // Driver Codepublic static void Main(String[] args) /*              45            /                31      14          /      /         thirteen  20   7   11       /       12  7    Create a priority queue proven in    instance in a binary max heap shape.    Queue might be represented in the    form of array as:    45 31 14 13 20 7 eleven 12 7 */     // Insert the element to the choices    // priority queue    insert(forty five);    insert(20);    insert(14);    insert(12);    insert(31);    insert(7);    insert(11);    insert(thirteen);    insert(7);         int i = 0;         // Priority queue earlier than extracting max    Console.Write(“Priority Queue : “);    at the same time as (i <= length)            Console.Write(H[i] + " ");        i++;             Console.Write("n");         // Node with most priority    Console.Write("Node with maximum precedence : " +                   extractMax() + "n");         // Priority queue after extracting max    Console.Write("Priority queue after " +                  "extracting maximum : ");    int j = zero;    whilst (j <= length)            Console.Write(H[j] + " ");        j++;             Console.Write("n");         // Change the concern of element    // present at index 2 to forty nine    changePriority(2, 49);    Console.Write("Priority queue after " +                  "priority trade : ");    int ok = zero;    even as (okay <= length)            Console.Write(H[k] + " ");        okay++;             Console.Write("n");         // Remove element at index three    Remove(three);    Console.Write("Priority queue after " +                  "disposing of the detail : ");    int l = zero;    even as (l <= size)            Console.Write(H[l] + " ");        l++;     // This code is contributed by means of Amit KatiyarOutput: Priority Queue : 45 31 14 thirteen 20 7 eleven 12 7  Node with most priority : forty five  Priority queue after extracting most : 31 20 14 13 7 7 eleven 12  Priority queue after precedence exchange : 49 20 31 thirteen 7 7 eleven 12  Priority queue after eliminating the choices detail : 49 20 31 12 7 7 eleven Time Complexity: The time complexity of all of the operation is O(log N) besides for GetMax() which has time complexity of O(1). Auxiliary Space: O(N) Attention reader! Don’t forestall gaining knowledge of now. Get keep of all of the crucial DSA standards with the choices DSA Self Paced Course at a scholar-friendly price and emerge as enterprise geared up.  To complete your instruction from gaining knowledge of a language to DS Algo and lots of more,  please refer Complete Interview Preparation Course.In case you want to attend live lessons with specialists, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.My Personal Notes arrow_drop_upSave