Encuentra la altura del árbol binario 【Java】

Resumen

　　Atravesar un árbol binario ya se ha mencionado en el artículo anterior, entonces, ¿cómo encontrar la altura de un árbol binario? Esta conferencia hablará sobre este tema.

Ideas

　　De hecho, esta idea es difícil de aclarar. El significado general es aumentar la altura en 1 cada vez que se atraviesa una capa. Entonces surge la pregunta, ¿cómo puedo juzgar que esta capa de recorrido ha terminado? Esto se puede hacer registrando el número de cada capa, y luego, después de atravesar cada capa de esta capa, significa que esta capa ha sido atravesada, entonces la pregunta es nuevamente, ¿cómo registrar el número de cada capa? Este es un truco, la idea es esta, usar dos recorridos al mismo tiempo, cuando el primer recorrido atraviesa la siguiente capa, el segundo atraviesa la capa anterior, cuando se atraviesa la capa anterior, la siguiente capa Se atravesará, y luego en este proceso, puede aumentar la altura en 1 a través de algunas banderas.

　　Puede ser más confuso leer las ideas anteriores. Veamos el código directamente a continuación.

El código básico es la composición del árbol binario y el código de cada nodo.

Árbol binario:

paquete com.example.demo.tree; 

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import org.omg.PortableInterceptor.INACTIVE; 

import java.util.Comparator; 

/ ** 
 * @author steve 
 * @date 2020/4/16 10:03 上午
 * / 
public  class BinaryTree <E> { 

    tamaño int privado  ;
    Nodo público <E> raíz;
    comparador privado <E> comparador; public BinaryTree (Comparador <E> comparador) {
         this .comparator = comparator; 
    }

    

    public BinaryTree () {
         this ( null ); 
    } 

    public  void add (elemento E) {
         if (root == null ) { 
            Node node = new Node (element); 
            raíz = nodo; 
        } else { 
            Nodo <E> parent = root; 
            Nodo <E> nodo = raíz;
            int com = 0 ;
            while (nodo! = nulo ) { 
                parent =nodo;
                if (comparador == nulo ) { 
                    com = ((Comparable) node.element) .compareTo (elemento); 
                } else { 
                    System.out.println ( "-------------" ); 
                    com = comparator.compare (nodo.elemento, elemento); 
                } 
                if (com> 0 ) { 
                    nodo = nodo.left; 
                } else  if (com <0 ) { 
                    node = node.right; 
                }else { 
                    node.element = element;
                    volver ; 
                } 
            } 
            Nodo <E> nuevoNodo = nuevo Nodo (elemento);
            if (com> 0 ) { 
                parent.left = newNode; 
                newNode.parent = parent.left; 
            } else { 
                parent.right = newNode; 
                newNode.parent = parent.right; 
            } 
        } 
        tamaño++ ; 
    } 
    public  boolean isEmpty () {
         return size == 0 ; 
    } 
    public  int size () {
         return size; 
    } 

    public String toString () { 
        String d = root == null ? nulo : root.element + "" ;
        if (root == null ) {
             return "root:" + d; 
        } else { 
            String b = root.left == null ? nulo: root.left.element + "" ; 
            Cadena c = root.right == null ? null : root.right.element + "" ;
             return "root:" + d + ", left:" + b + ", right : "+ c; 
        } 

    } 


    public  static  void main (String [] args) {
         // Este método es una clase interna anónima, al pasar una interfaz como parámetro a una clase, y luego esto se realiza mediante una clase interna anónima Implementación entrante. 
        BinaryTree <Integer> binaryTree = new BinaryTree <> ( new Comparator <Integer> () { 
            @Override 
            public  int compare (Integer o1,
                o1 - o2; 
            } 
        }); 

        BinaryTree <Integer> binaryTree1 = new BinaryTree <> (); 
        binaryTree1.add ( 1 ); 
        binaryTree1.add ( 2 ); 
        binaryTree1.add ( 0 ); 
        System.out.println (binaryTree1.size ()); 
        System.out.println (binaryTree.toString ()); 
    } 
}

Ver código

Nodo:

paquete com.example.demo.tree; 

/ ** 
 * @ autor steve 
 * @date 2020/4/18 3:16 下午
 * / 
public  class Node <E> {
     public Node <E> left;
    Nodo público <E> derecho;
    Nodo público <E> padre;
    elemento E público ;
    Nodo público (elemento E) {
         this .element = element; 
    } 
}

Ver código

Determinar la altura de un árbol binario.

package com.example.demo.tree; 

import java.util.ArrayList;
 import java.util.List; 

/ ** 
 * @author steve 
 * @date 2020/4/20 6:36 pm 
 * @description Encuentra la altura del árbol binario , A través de la recursión y la iteración 
 * / 
public  class BinaryTreeHeight { 

    / ** 
     * encuentra la altura del árbol binario a través de la recursión, de esta manera es difícil pensar 
     * @param node
      * / 
    public  static  int getHeightByRecursion (Node <Integer> node) {
         if (nodo == nulo || nodo == nulo ) devuelve 0 ;
         intleft = getHeightByRecursion (node.left);
         int right = getHeightByRecursion (node.right);
         if (left> right) {
             return left + 1 ; 
        } else {
             return right + 1 ; 
        } 
    } 

    / ** 
     * Encuentra el árbol binario por iteración La altura 
     * @param node
      * / 
    public  static  void getHeightByIteration (Nodo <Integer> nodo) { 
　　　　　// Este es el subíndice de iteración lenta
         int front = -1 ; 
        // Este es el subíndice al final de cada capa
        int last = 0 ; 
        // 树 的 高度
         int height = 0 ; 
        // 这个 是 快 迭代 的 下 标
         int rear = -1 ; 

        List <Node <Integer>> linkList = new ArrayList <> (); 
        linkList.add ( ++ posterior, nodo); 
        Nodo <Intero> nodo1 = nulo ;
        mientras que (frontal < trasera) { 
            node1 = linkList.get (++ frontal);
            if (node1.left! = null ) { 
                linkList.add ( ++ rear, node1.left);
            }
             if (node1.right! = null ) { 
                linkList.add ( ++ rear, node1.right); 
            } 
            if (front == last) { 
                height ++ ; 
                último = trasero; 
            } 

        } 
        System.out.println (altura); 
    } 

    public  static  void main (String [] args) { 
        BinaryTree <Integer> binaryTree = new BinaryTree (); 
        binaryTree.add ( 7 ); 
        binaryTree.add ( 4 ); 
        binaryTree.add ( 10 ); 
        binaryTree.add ( 9 ); 
        binaryTree.add ( 11 ); 
        binaryTree.add ( 5 ); 
        binaryTree.add ( 3 ); 
        binaryTree.add ( 1 ); 
        binaryTree.add ( 0 );
        int height = getHeightByRecursion (binaryTree.root); 
        System.out.println (altura); 
        getHeightByIteration (binaryTree.root); 
    } 
}