Introduction to Max-Heap – Data Structure and Algorithm Tutorials

// C# program for implementing insertion in Heaps

using System;

public class insertionHeap {

    // Function to heapify ith node in a Heap of size n following a Bottom-up approach
    static void heapify(int[] arr, int n, int i) {
        // Find parent
        int parent = (i - 1) / 2;

        if (arr[parent] > 0) {
            // For Max-Heap
            // If current node is greater than its parent
            // Swap both of them and call heapify again
            // for the parent
            if (arr[i] > arr[parent]) {

                // swap arr[i] and arr[parent]
                int temp = arr[i];
                arr[i] = arr[parent];
                arr[parent] = temp;

                // Recursively heapify the parent node
                heapify(arr, n, parent);
            }
        }
    }

    // Function to insert a new node to the heap.
    static int insertNode(int[] arr, int n, int Key) {
        // Increase the size of Heap by 1
        n = n + 1;

        // Insert the element at end of Heap
        arr[n - 1] = Key;

        // Heapify the new node following a
        // Bottom-up approach
        heapify(arr, n, n - 1);

        // return new size of Heap
        return n;
    }

    /* A utility function to print array of size n */
    static void printArray(int[] arr, int n) {
        for (int i = 0; i < n; ++i)
            Console.WriteLine(arr[i] + " ");

        Console.WriteLine("");
    }

    public static void Main(string[] args) {
        // Array representation of Max-Heap
        //     10
        // / \
        // 5 3
        // / \
        // 2 4

        // maximum size of the array
        int MAX = 1000;
        int[] arr = new int[MAX];

        // initializing some values
        arr[0] = 10;
        arr[1] = 5;
        arr[2] = 3;
        arr[3] = 2;
        arr[4] = 4;

        // Current size of the array
        int n = 5;

        // the element to be inserted
        int Key = 15;

        // The function inserts the new element to the heap and
        // returns the new size of the array
        n = insertNode(arr, n, Key);

        printArray(arr, n);
        // Final Heap will be:
        //     15
        // / \
        // 5     10
        // / \ /
        // 2 4 3
    }
}

// This code is contributed by ajaymakvana.

// C# program for implement deletion in Heaps
using System;

public class deletionHeap
{

    // To heapify a subtree rooted with node i which is
    // an index in arr[].Nn is size of heap
    static void heapify(int []arr, int n, int i)
    {
        int largest = i; // Initialize largest as root
        int l = 2 * i + 1; // left = 2*i + 1
        int r = 2 * i + 2; // right = 2*i + 2

        // If left child is larger than root
        if (l < n && arr[l] > arr[largest])
            largest = l;

        // If right child is larger than largest so far
        if (r < n && arr[r] > arr[largest])
            largest = r;

        // If largest is not root
        if (largest != i)
        {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;

            // Recursively heapify the affected sub-tree
            heapify(arr, n, largest);
        }
    }

    // Function to delete the root from Heap
    static int deleteRoot(int []arr, int n)
    {
        // Get the last element
        int lastElement = arr[n - 1];

        // Replace root with first element
        arr[0] = lastElement;

        // Decrease size of heap by 1
        n = n - 1;

        // heapify the root node
        heapify(arr, n, 0);

        // return new size of Heap
        return n;
    }

    /* A utility function to print array of size N */
    static void printArray(int []arr, int n)
    {
        for (int i = 0; i < n; ++i)
            Console.Write(arr[i] + " ");

        Console.WriteLine();
    }

    // Driver Code
    public static void Main()
    {
        // Array representation of Max-Heap
        // 10
        // / \
        // 5 3
        // / \
        // 2 4
        int []arr = { 10, 5, 3, 2, 4 };
        int n = arr.Length;
        n = deleteRoot(arr, n);
        printArray(arr, n);
    }
}

// This code is contributed by Ryuga

using System;
using System.Collections.Generic;

public class GFG {
    public static void Main() {
        // Create a min heap with some elements using a PriorityQueue
        var maxHeap = new PriorityQueue<int>();
        maxHeap.Enqueue(9);
        maxHeap.Enqueue(8);
        maxHeap.Enqueue(7);
        maxHeap.Enqueue(6);
        maxHeap.Enqueue(5);
        maxHeap.Enqueue(4);
        maxHeap.Enqueue(3);
        maxHeap.Enqueue(2);
        maxHeap.Enqueue(1);

        // Get the peak element (i.e., the smallest element)
        int peakElement = maxHeap.Peek();

        // Print the peak element
        Console.WriteLine("Peak element: " + peakElement);
    }
}
// Define a PriorityQueue class that uses a max heap
class PriorityQueue<T> where T : IComparable<T> {
    private List<T> heap;

    public PriorityQueue() {
        this.heap = new List<T>();
    }

    public int Count {
        get { return this.heap.Count; }
    }

    public void Enqueue(T item) {
        this.heap.Add(item);
        this.BubbleUp(this.heap.Count - 1);
    }

    public T Dequeue() {
        T item = this.heap[0];
        int lastIndex = this.heap.Count - 1;
        this.heap[0] = this.heap[lastIndex];
        this.heap.RemoveAt(lastIndex);
        this.BubbleDown(0);
        return item;
    }

    public T Peek() {
        return this.heap[0];
    }

    private void BubbleUp(int index) {
        while (index > 0) {
            int parentIndex = (index - 1) / 2;
            if (this.heap[parentIndex].CompareTo(this.heap[index]) >= 0) {
                break;
            }
            Swap(parentIndex, index);
            index = parentIndex;
        }
    }

    private void BubbleDown(int index) {
        while (index < this.heap.Count) {
            int leftChildIndex = index * 2 + 1;
            int rightChildIndex = index * 2 + 2;
            int largestChildIndex = index;
            if (leftChildIndex < this.heap.Count && this.heap[leftChildIndex].CompareTo(this.heap[largestChildIndex]) > 0) {
                largestChildIndex = leftChildIndex;
            }
            if (rightChildIndex < this.heap.Count && this.heap[rightChildIndex].CompareTo(this.heap[largestChildIndex]) > 0) {
                largestChildIndex = rightChildIndex;
            }
            if (largestChildIndex == index) {
                break;
            }
            Swap(largestChildIndex, index);
            index = largestChildIndex;
        }
    }

    private void Swap(int i, int j) {
        T temp = this.heap[i];
        this.heap[i] = this.heap[j];
        this.heap[j] = temp;
    }
}

using System;
using System.Collections.Generic;

class Program {
    static void Main(string[] args) {
        // Create a max heap with some elements using a PriorityQueue
        PriorityQueue<int> maxHeap = new PriorityQueue<int>();
        maxHeap.Enqueue(10);
        maxHeap.Enqueue(9);
        maxHeap.Enqueue(8);
        maxHeap.Enqueue(6);
        maxHeap.Enqueue(4);

        int element = 6; // element to search for
        bool found = false;

        // Copy the max heap to a temporary queue and search for the element
        PriorityQueue<int> temp = new PriorityQueue<int>(maxHeap);
        while (temp.Count > 0) {
            if (temp.Peek() == element) {
                found = true;
                break;
            }
            temp.Dequeue();
        }

        if (found) {
            Console.WriteLine("Element found in the max heap.");
        } else {
            Console.WriteLine("Element not found in the max heap.");
        }
    }
}

// PriorityQueue class
class PriorityQueue<T> where T : IComparable<T> {
    private List<T> heap = new List<T>();

    public void Enqueue(T item) {
        heap.Add(item);
        int child = heap.Count - 1;
        while (child > 0) {
            int parent = (child - 1) / 2;
            if (heap[child].CompareTo(heap[parent]) > 0) {
                T tmp = heap[child];
                heap[child] = heap[parent];
                heap[parent] = tmp;
                child = parent;
            } else {
                break;
            }
        }
    }

    public T Dequeue() {
        int last = heap.Count - 1;
        T frontItem = heap[0];
        heap[0] = heap[last];
        heap.RemoveAt(last);

        last--;

        int parent = 0;
        while (true) {
            int leftChild = parent * 2 + 1;
            if (leftChild > last) {
                break;
            }
            int rightChild = leftChild + 1;
            if (rightChild <= last && heap[leftChild].CompareTo(heap[rightChild]) < 0) {
                leftChild = rightChild;
            }
            if (heap[parent].CompareTo(heap[leftChild]) < 0) {
                T tmp = heap[parent];
                heap[parent] = heap[leftChild];
                heap[leftChild] = tmp;
                parent = leftChild;
            } else {
                break;
            }
        }

        return frontItem;
    }

    public T Peek() {
        return heap[0];
    }

    public int Count {
        get {
            return heap.Count;
        }
    }
}