Esta subsección describe cómo agregar elementos a un montón máximo, llamado shift up .
Supongamos que agregamos un nuevo elemento 52 al montón máximo a continuación y lo colocamos en la última posición de la matriz. 52 es mayor que el nodo principal 16. En este momento, la definición del montón no cumple con la definición y necesita ser ajustado
Primero intercambie las posiciones de los valores en la matriz con los índices 5 y 11, es decir, 52 y 16 intercambien posiciones.
En este momento, 52 sigue siendo mayor que el valor 41 cuyo índice de nodo principal es 2, y debemos avanzar más.
En este momento, compare los tamaños de 52 y 62. 52 ya es más pequeño que el nodo principal y no es necesario aumentarlo, lo que cumple con la definición del montón máximo. Llamamos a este proceso un cambio hacia arriba del montón máximo.
Código de ejemplo Java
código de archivo src/runoob/heap/HeapShiftUp.java:
paquete runoob.heap;
/**
* Agrega un elemento al montón
*/
public class HeapShiftUp<T extends Comparable> { protected T[] data; protected int count; protected int capacity; // Constructor, construye un montón vacío, Can acomodar elementos de capacidad public HeapShiftUp(int capacity){ data = (T[])new Comparable[capacity+1]; count = 0; this.capacity = capacidad; } // devuelve el número de elementos en el montón public int size ( ){ return count; } // Devuelve un valor booleano que indica si el montón está vacío public boolean isEmpty(){ return count == 0; } // Inserta un nuevo elemento en el montón más grande
public void insert(T elemento){ afirmar cuenta + 1 <= capacidad; datos[cuenta+1] = elemento; cuenta ++; shiftUp(cuenta); } // Intercambia los dos elementos con índice i y j en el montón privado void swap(int i, int j){ T t = datos[i]; datos[i] = datos[j]; datos[j] = t; } //************ ********* //* Función auxiliar de núcleo de montón máximo //******************** privado void shiftUp(int k){ while( k > 1 && data[k/2].compareTo(data[k]) < 0 ){ swap(k, k/2); k /= 2; } } // prueba HeapShiftUp
public static void main(String[] args) { HeapShiftUp<Integer> heapShiftUp = new HeapShiftUp<Integer>(100); int N = 50; // número de elementos en el montón int M = 100; // valor de los elementos en el rango del montón[0, M) for( int i = 0 ; i < N ; i ++ ) heapShiftUp.insert( new Integer((int)(Math.random() * M)) ); System.out.println (heapShiftUp .size()); } }