Un montón binario es un montón especial. Un montón binario es un árbol binario completo (árbol binario) o un árbol binario aproximadamente completo (árbol binario). Hay dos tipos de montones binarios: el montón más grande y el montón más pequeño. Máximo montón: el valor clave del nodo principal es siempre mayor o igual al valor clave de cualquier nodo hijo; Mínimo montón: el valor clave del nodo principal es siempre menor o igual al valor clave de cualquier nodo hijo.
Imprimir montón binario: utilizar relaciones jerárquicas
Aquí primero ordeno el montón y luego ejecuto el método para imprimir el montón en la ordenación printAsTree()
clase pública maxheap <t se extiende comparable <? Super t >> {private t [] datos; tamaño privado int; Capacidad privada int; public maxheap (int capacidad) {this.capacity = capacidad; this.size = 0; this.data = (t []) nuevo comparable [capacidad + 1]; } public maxHeap (t [] arr) {// Heapify, array Heap Capacidad = arr.length; data = (t []) nuevo comparable [Capacidad + 1]; System.ArrayCopy (arr, 0, datos, 1, arr.length); tamaño = arr.length; for (int i = size / 2; i> = 1; i--) {shiftdown (i); }} public int size () {return this.size; } public int getCapacity () {return this.capacity; } public boolean isEtimty () {return size == 0; } public t Seekmax () {Data de retorno [1]; } public void swap (int i, int j) {if (i! = j) {t temp = data [i]; datos [i] = data [j]; datos [j] = temp; }} public void Insert (t item) {size ++; datos [tamaño] = elemento; ShiftUp (tamaño); } public t popmax () {swap (1, tamaño--); Shiftdown (1); Datos de devolución [tamaño + 1]; } public void shiftUp (int child) {while (child> 1 && data [child] .compareto (data [child / 2])> 0) {swap (niño, niño / 2); niño /= 2; }}/*** @param una marca de esquina inferior de un elemento en la matriz de datos* @param B Marca de esquina inferior de un elemento en la matriz de datos* @return return ¿Qué elemento es más grande, la marca de esquina inferior de la que es más grande*/private int max (int a, int b) {if (data [a] .compareto (datos [b]) <0) {// if datos [b] big retorno b; datos [a] Big return a; // return a}}/*** @param Una marca de esquina inferior de un elemento en la matriz de datos* @param B Marca de esquina inferior de un elemento en la matriz de datos* @param c La marca de esquina inferior de un elemento en la matriz de datos* @return la marca de la esquina inferior de qué elemento es más grande*/privado int max (int a, int b, int c) {int más grande = max (a, b, b, b, b, b, b); más grande = max (más grande, c); regresar más grande; } public void shiftdown (int padre) {while (true) {int lchild = padre * 2; int rchild = padre * 2 + 1; int Newfather = Padre; // No importa si la tarea se asigna aquí. Si se cambia el siguiente regreso para romper, se debe asignar si (lChild> size) {// si no hay regreso a los niños a la izquierda y a la derecha; } else if (rchild> size) {// Si no hay un niño correcto neofather = max (padre, lChild); } else {// Si hay un niño de izquierda y derecho novato = max (padre, lchild, rchild); } if (novato == padre) {// Si el nodo principal original es el más grande de tres, no necesita continuar ordenando el retorno de la pila; } else {// El nodo principal no es el más grande, intercambia a los niños mayores y continúa ajustando la baja hasta que el montón de raíz grande esté satisfecho (novato, padre); Padre = novato; // equivalente a Shiftdown (novato). Si el novato resulta ser el hijo izquierdo del padre, es equivalente a Shiftdown (2*padre)}}} Public Static <t se extiende comparable <? Super t >> void sort (t [] arr) {int len = arr.length; Maxheap <t> maxheap = new MaxHeap <> (arr); maxHeap.printastree (); for (int i = len-1; i> = 0; i--) {arr [i] = maxheap.popmax (); }} public static void printarr (objeto [] arr) {for (object o: arr) {system.out.print (o); System.out.print ("/t"); } System.out.println (); } public void printspace (int n) {// imprime n espacios (usados con '/t' aquí en su lugar) para (int i = 0; i <n; i ++) {system.out.printf ("%3s", ""); }} public void PrintArree () {int Linenum = 1; // Primero recorrer las líneas de primera línea int = (int) (math.log (size)/math.log (2)) + 1; // Las líneas son el número de capas del montón int spacenum = (int) (math.pow (2, líneas) - 1); para (int i = 1; i <= size;) {// porque los datos se almacenan en el intervalo cerrado izquierdo y derecho en [1 ... tamaño], los datos [0] no almacenan datos // cada capa imprime este intervalo [2^(número de capa-1) ... (número 2^de capa) -1]. Si el número en el montón no es suficiente (2^ capas) -1, imprima en tamaño. Así que tome min ((2^ capas) -1, tamaño). para (int j = (int) math.pow (2, lino - 1); j <= math.min (tamaño, (int) math.pow (2, lino) - 1); j ++) {printspace (spacenum); // Imprimir espacios con Spacenum System.out.printf ("%3s", datos [j]); // Imprimir datos System.out.printf ("%3s", ""); // caja verde en la imagen printspace (Spacenum); // Imprimir espacios con Spacenum I ++; // Cada elemento está impreso, es+1} Lineno ++; Spacenum = Spacenum / 2; System.out.println (); }} public static void main (string args []) {integer [] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6, 1, 3, 6, 1, 1}; ordenar (arr); }}Resultados de la ejecución:
Resumir
Lo anterior es todo el contenido de este artículo sobre el código de impresión compartido del idioma Java que implementa montones binarios. Espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!