montón binario

Un montón binario es un árbol binario con las siguientes propiedades.
1) Es un árbol completo (Todos los niveles están completamente llenos, excepto posiblemente el último nivel y el último nivel tiene todas las claves tan a la izquierda como sea posible). Esta propiedad de Binary Heap los hace aptos para almacenarse en una array.

2) Un montón binario es un montón mínimo o un montón máximo. En un montón binario mínimo, la clave en la raíz debe ser mínima entre todas las claves presentes en el montón binario. La misma propiedad debe ser recursivamente verdadera para todos los Nodes en Binary Tree. Max Binary Heap es similar a MinHeap.

Ejemplos de montón mínimo:

            10                      10
         /      \               /       \  
       20        100          15         30  
      /                      /  \        /  \
    30                     40    50    100   40

¿Cómo se representa Binary Heap?
Un montón binario es un árbol binario completo. Un montón binario normalmente se representa como una array.

  • El elemento raíz estará en Arr[0].
  • La siguiente tabla muestra índices de otros Nodes para el i -ésimo Node, es decir, Arr[i]:
    Arr[(i-1)/2] Devuelve el Node padre
    Arr[(2*i)+1] Devuelve el Node secundario izquierdo
    Arr[(2*i)+2] Devuelve el Node secundario derecho
  • El uso del método transversal para lograr la representación de array es el orden de nivel
    Binary Heap Tree

    Consulte Representación de array de almacenamiento dinámico binario para obtener más información.

    Aplicaciones de montones:
    1) Heap Sort : Heap Sort usa Binary Heap para ordenar una array en tiempo O (nLogn).

    2) Cola de prioridad: las colas de prioridad se pueden implementar de manera eficiente utilizando Binary Heap porque admite operaciones de inserción(), eliminación() y extractmax(), disminución de clave() en tiempo O (logn). Binomoial Heap y Fibonacci Heap son variaciones de Binary Heap. Estas variaciones realizan la unión también de manera eficiente.

    3) Algoritmos gráficos: las colas de prioridad se utilizan especialmente en algoritmos gráficos como el camino más corto de Dijkstra y el árbol de expansión mínimo de Prim .

    4) Muchos problemas pueden resolverse eficientemente usando Heaps. Consulte lo siguiente, por ejemplo.
    a) K-ésimo elemento más grande en una array .
    b) Ordenar una array casi ordenada/
    c) Fusionar K arrays ordenadas .

    Operaciones en Min Heap:
    1) getMini(): Devuelve el elemento raíz de Min Heap. La complejidad temporal de esta operación es O(1).

    2) extractMin(): elimina el elemento mínimo de MinHeap. La complejidad de tiempo de esta operación es O (Inicio de sesión) ya que esta operación necesita mantener la propiedad del montón (llamando a heapify()) después de eliminar la raíz.

    3) disminuirKey(): Disminuye el valor de la clave. La complejidad temporal de esta operación es O(Logn). Si el valor de la clave de disminución de un Node es mayor que el padre del Node, entonces no necesitamos hacer nada. De lo contrario, debemos recorrer hacia arriba para corregir la propiedad del montón violada.

    4) insertar(): insertar una nueva clave lleva tiempo O (Iniciar sesión). Agregamos una nueva clave al final del árbol. SI la nueva clave es mayor que su padre, entonces no necesitamos hacer nada. De lo contrario, debemos recorrer hacia arriba para corregir la propiedad del montón violada.

    5) eliminar(): eliminar una clave también lleva tiempo O (Iniciar sesión). Reemplazamos la clave que se eliminará con un mínimo infinito llamando a decrementarKey(). Después de disminuirKey(), el valor infinito menos debe llegar a la raíz, por lo que llamamos a extractMin() para eliminar la clave.

    A continuación se muestra la implementación de las operaciones básicas del montón.

    C++

    // A C++ program to demonstrate common Binary Heap Operations
    #include<iostream>
    #include<climits>
    using namespace std;
      
    // Prototype of a utility function to swap two integers
    void swap(int *x, int *y);
      
    // A class for Min Heap
    class MinHeap
    {
        int *harr; // pointer to array of elements in heap
        int capacity; // maximum possible size of min heap
        int heap_size; // Current number of elements in min heap
    public:
        // Constructor
        MinHeap(int capacity);
      
        // to heapify a subtree with the root at given index
        void MinHeapify(int );
      
        int parent(int i) { return (i-1)/2; }
      
        // to get index of left child of node at index i
        int left(int i) { return (2*i + 1); }
      
        // to get index of right child of node at index i
        int right(int i) { return (2*i + 2); }
      
        // to extract the root which is the minimum element
        int extractMin();
      
        // Decreases key value of key at index i to new_val
        void decreaseKey(int i, int new_val);
      
        // Returns the minimum key (key at root) from min heap
        int getMin() { return harr[0]; }
      
        // Deletes a key stored at index i
        void deleteKey(int i);
      
        // Inserts a new key 'k'
        void insertKey(int k);
    };
      
    // Constructor: Builds a heap from a given array a[] of given size
    MinHeap::MinHeap(int cap)
    {
        heap_size = 0;
        capacity = cap;
        harr = new int[cap];
    }
      
    // Inserts a new key 'k'
    void MinHeap::insertKey(int k)
    {
        if (heap_size == capacity)
        {
            cout << "\nOverflow: Could not insertKey\n";
            return;
        }
      
        // First insert the new key at the end
        heap_size++;
        int i = heap_size - 1;
        harr[i] = k;
      
        // Fix the min heap property if it is violated
        while (i != 0 && harr[parent(i)] > harr[i])
        {
           swap(&harr[i], &harr[parent(i)]);
           i = parent(i);
        }
    }
      
    // Decreases value of key at index 'i' to new_val.  It is assumed that
    // new_val is smaller than harr[i].
    void MinHeap::decreaseKey(int i, int new_val)
    {
        harr[i] = new_val;
        while (i != 0 && harr[parent(i)] > harr[i])
        {
           swap(&harr[i], &harr[parent(i)]);
           i = parent(i);
        }
    }
      
    // Method to remove minimum element (or root) from min heap
    int MinHeap::extractMin()
    {
        if (heap_size <= 0)
            return INT_MAX;
        if (heap_size == 1)
        {
            heap_size--;
            return harr[0];
        }
      
        // Store the minimum value, and remove it from heap
        int root = harr[0];
        harr[0] = harr[heap_size-1];
        heap_size--;
        MinHeapify(0);
      
        return root;
    }
      
      
    // This function deletes key at index i. It first reduced value to minus
    // infinite, then calls extractMin()
    void MinHeap::deleteKey(int i)
    {
        decreaseKey(i, INT_MIN);
        extractMin();
    }
      
    // A recursive method to heapify a subtree with the root at given index
    // This method assumes that the subtrees are already heapified
    void MinHeap::MinHeapify(int i)
    {
        int l = left(i);
        int r = right(i);
        int smallest = i;
        if (l < heap_size && harr[l] < harr[i])
            smallest = l;
        if (r < heap_size && harr[r] < harr[smallest])
            smallest = r;
        if (smallest != i)
        {
            swap(&harr[i], &harr[smallest]);
            MinHeapify(smallest);
        }
    }
      
    // A utility function to swap two elements
    void swap(int *x, int *y)
    {
        int temp = *x;
        *x = *y;
        *y = temp;
    }
      
    // Driver program to test above functions
    int main()
    {
        MinHeap h(11);
        h.insertKey(3);
        h.insertKey(2);
        h.deleteKey(1);
        h.insertKey(15);
        h.insertKey(5);
        h.insertKey(4);
        h.insertKey(45);
        cout << h.extractMin() << " ";
        cout << h.getMin() << " ";
        h.decreaseKey(2, 1);
        cout << h.getMin();
        return 0;
    }

    Python

    # A Python program to demonstrate common binary heap operations
      
    # Import the heap functions from python library
    from heapq import heappush, heappop, heapify 
      
    # heappop - pop and return the smallest element from heap
    # heappush - push the value item onto the heap, maintaining
    #             heap invarient
    # heapify - transform list into heap, in place, in linear time
      
    # A class for Min Heap
    class MinHeap:
          
        # Constructor to initialize a heap
        def __init__(self):
            self.heap = [] 
      
        def parent(self, i):
            return (i-1)/2
          
        # Inserts a new key 'k'
        def insertKey(self, k):
            heappush(self.heap, k)           
      
        # Decrease value of key at index 'i' to new_val
        # It is assumed that new_val is smaller than heap[i]
        def decreaseKey(self, i, new_val):
            self.heap[i]  = new_val 
            while(i != 0 and self.heap[self.parent(i)] > self.heap[i]):
                # Swap heap[i] with heap[parent(i)]
                self.heap[i] , self.heap[self.parent(i)] = (
                self.heap[self.parent(i)], self.heap[i])
                  
        # Method to remove minium element from min heap
        def extractMin(self):
            return heappop(self.heap)
      
        # This functon deletes key at index i. It first reduces
        # value to minus infinite and then calls extractMin()
        def deleteKey(self, i):
            self.decreaseKey(i, float("-inf"))
            self.extractMin()
      
        # Get the minimum element from the heap
        def getMin(self):
            return self.heap[0]
      
    # Driver pgoratm to test above function
    heapObj = MinHeap()
    heapObj.insertKey(3)
    heapObj.insertKey(2)
    heapObj.deleteKey(1)
    heapObj.insertKey(15)
    heapObj.insertKey(5)
    heapObj.insertKey(4)
    heapObj.insertKey(45)
      
    print heapObj.extractMin(),
    print heapObj.getMin(),
    heapObj.decreaseKey(2, 1)
    print heapObj.getMin()
      
    # This code is contributed by Nikhil Kumar Singh(nickzuck_007)

    C#

    // C# program to demonstrate common 
    // Binary Heap Operations - Min Heap
    using System;
      
    // A class for Min Heap 
    class MinHeap{
          
    // To store array of elements in heap
    public int[] heapArray{ get; set; }
      
    // max size of the heap
    public int capacity{ get; set; }
      
    // Current number of elements in the heap
    public int current_heap_size{ get; set; }
      
    // Constructor 
    public MinHeap(int n)
    {
        capacity = n;
        heapArray = new int[capacity];
        current_heap_size = 0;
    }
      
    // Swapping using reference 
    public static void Swap<T>(ref T lhs, ref T rhs)
    {
        T temp = lhs;
        lhs = rhs;
        rhs = temp;
    }
      
    // Get the Parent index for the given index
    public int Parent(int key) 
    {
        return (key - 1) / 2;
    }
      
    // Get the Left Child index for the given index
    public int Left(int key)
    {
        return 2 * key + 1;
    }
      
    // Get the Right Child index for the given index
    public int Right(int key)
    {
        return 2 * key + 2;
    }
      
    // Inserts a new key
    public bool insertKey(int key)
    {
        if (current_heap_size == capacity)
        {
              
            // heap is full
            return false;
        }
      
        // First insert the new key at the end 
        int i = current_heap_size;
        heapArray[i] = key;
        current_heap_size++;
      
        // Fix the min heap property if it is violated 
        while (i != 0 && heapArray[i] < 
                         heapArray[Parent(i)])
        {
            Swap(ref heapArray[i],
                 ref heapArray[Parent(i)]);
            i = Parent(i);
        }
        return true;
    }
      
    // Decreases value of given key to new_val. 
    // It is assumed that new_val is smaller 
    // than heapArray[key]. 
    public void decreaseKey(int key, int new_val)
    {
        heapArray[key] = new_val;
      
        while (key != 0 && heapArray[key] < 
                           heapArray[Parent(key)])
        {
            Swap(ref heapArray[key], 
                 ref heapArray[Parent(key)]);
            key = Parent(key);
        }
    }
      
    // Returns the minimum key (key at
    // root) from min heap 
    public int getMin()
    {
        return heapArray[0];
    }
      
    // Method to remove minimum element 
    // (or root) from min heap 
    public int extractMin()
    {
        if (current_heap_size <= 0)
        {
            return int.MaxValue;
        }
      
        if (current_heap_size == 1)
        {
            current_heap_size--;
            return heapArray[0];
        }
      
        // Store the minimum value, 
        // and remove it from heap 
        int root = heapArray[0];
      
        heapArray[0] = heapArray[current_heap_size - 1];
        current_heap_size--;
        MinHeapify(0);
      
        return root;
    }
      
    // This function deletes key at the 
    // given index. It first reduced value 
    // to minus infinite, then calls extractMin()
    public void deleteKey(int key)
    {
        decreaseKey(key, int.MinValue);
        extractMin();
    }
      
    // A recursive method to heapify a subtree 
    // with the root at given index 
    // This method assumes that the subtrees
    // are already heapified
    public void MinHeapify(int key)
    {
        int l = Left(key);
        int r = Right(key);
      
        int smallest = key;
        if (l < current_heap_size && 
            heapArray[l] < heapArray[smallest])
        {
            smallest = l;
        }
        if (r < current_heap_size && 
            heapArray[r] < heapArray[smallest])
        {
            smallest = r;
        }
          
        if (smallest != key)
        {
            Swap(ref heapArray[key], 
                 ref heapArray[smallest]);
            MinHeapify(smallest);
        }
    }
      
    // Increases value of given key to new_val.
    // It is assumed that new_val is greater 
    // than heapArray[key]. 
    // Heapify from the given key
    public void increaseKey(int key, int new_val)
    {
        heapArray[key] = new_val;
        MinHeapify(key);
    }
      
    // Changes value on a key
    public void changeValueOnAKey(int key, int new_val)
    {
        if (heapArray[key] == new_val)
        {
            return;
        }
        if (heapArray[key] < new_val)
        {
            increaseKey(key, new_val);
        } else
        {
            decreaseKey(key, new_val);
        }
    }
    }
      
    static class MinHeapTest{
          
    // Driver code
    public static void Main(string[] args)
    {
        MinHeap h = new MinHeap(11);
        h.insertKey(3);
        h.insertKey(2);
        h.deleteKey(1);
        h.insertKey(15);
        h.insertKey(5);
        h.insertKey(4);
        h.insertKey(45);
          
        Console.Write(h.extractMin() + " ");
        Console.Write(h.getMin() + " ");
          
        h.decreaseKey(2, 1);
        Console.Write(h.getMin());
    }
    }
      
    // This code is contributed by 
    // Dinesh Clinton Albert(dineshclinton)

    Producción:

2 4 1

Práctica de codificación en el montón
Todos los artículos en el montón
Cuestionario en el montón
PriorityQueue: Implementación del montón binario en la biblioteca de Java

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *