Algunas operaciones básicas de árboles binarios (java)

Primero, defina la clase de nodo 
public class TreeNode { 
    int val; 
    TreeNode izquierda; 
    TreeNode derecha; 
    TreeNode(int val){ 
        this.val=val; 
        this.left=null; 
        this.right=null; 
    } 
}

A continuación, definimos un árbol binario e implementamos varios métodos.

import java.util.LinkedList; 
import java.util.Queue; 

public class BinaryTree { 
    public TreeNode root; 
    public BinaryTree(){ 
        root=null; 
    } 


    //Inserción en el árbol binario, si el elemento es más pequeño que el elemento, inserte el subárbol izquierdo del nodo, si es grande, inserte el subárbol derecho 
    public void insert(int val){ 
        root=insert(root,val); 
    } 

    public TreeNode insert(TreeNode node,int val){ 
        if(node== null){ 
            nodo=nuevo TreeNode(val ); 
        } 
        else { 
            if (val<=node.val){ 
                node.left=insert(node.left,val); 
            }else { 
                node.right=insert(node.right, valor); 
            } 
        }
        return node; 
    } 


    //Busca nodos según el valor, devuelve verdadero si hay uno, falso si no es 
    public boolean search(int val){ 
        return search(root,val); 
    } 

    public boolean search(TreeNode node,int val) { 
        if (node==null){ 
            return false; 
        }else if (node.val==val){ 
            return true; 
        }else if (val<node.val){ 
            return search(node.left,val); 
        }else { 
            return search(node.right,val); 
        } 
    } 


    //Eliminar nodo 
    public void eliminar(int val){ 
        root=delete(root,val); 
    }

    eliminar TreeNode público (nodo TreeNode, int val) { 
        if (node==null){ 
            return null; 
        }else if (val<node.val){ 
            node.left=delete(node.left,val); 
        }else if ( val> node.val){ 
            node.right=delete(node.right,val); 
        }else { 
            //Se ha encontrado el nodo 
            //1: El nodo que se eliminará es un nodo secundario 
            si (node.right== null && node.left==null ){ 
                node=null; 
            } 
            //2: El nodo que se eliminará es solo el nodo derecho 
            else if (node.left==null){ 
                node=node.right; 
            } 
            //3 : Para ser eliminado El nodo tiene solo el nodo izquierdo  
            else if (node.right==null){
                node=node.left; 
            } 
            //4: El nodo que se va a eliminar tiene nodos izquierdo y derecho 
            else { 
                //Encuentra el nodo mínimo del subárbol derecho del nodo 
                TreeNode temp=findMin(node.right); 
                node.val= temp .val; 
                node.right=delete(node.right,temp.val); 
            } 
        } 
        devolver nodo; 
    } 

    public TreeNode findMin(TreeNode node){ 
        while (node.left!=null){ 
            node=node.left; 
        } 
        nodo de retorno; 
    } 


    // Recorrido en orden 
    public void inorderTraversal(){ 
        inorderTraversal(root); 
    }

    public void inorderTraversal(nodo TreeNode){ 
        if (node!=null){ 
            inorderTraversal(node.left); 
            System.out.print(nodo.val+" "); 
            inorderTraversal(nodo.derecha); 
        } 
    } 


    //前序遍历
    public void proOrderTraversal(){ 
        proOrderTraversal(root); 
    } 

    public void proOrderTraversal(nodo TreeNode){ 
        if (nodo!=null){ 
            System.out.print(node.val+" "); 
            inorderTraversal(nodo.izquierda); 
            inorderTraversal(nodo.derecha); 
        } 
    } 

    //后序遍历
    public void postOrderTraversal(){
        proOrderTraversal(root); 
    } 

    public void postOrderTraversal (nodo TreeNode) {
        if (nodo!=null){ 
            inorderTraversal(nodo.izquierda); 
            inorderTraversal(nodo.derecha); 
            System.out.print(nodo.val+" "); 
        } 
    } 

    //层序遍历
    public void levelOrderTraversal(){ 
        if (root==null){ 
            return; 
        } 
        Cola<TreeNode> cola=nueva ListaEnlazada<>(); 
        cola.oferta(raíz); 
        while (!queue.isEmpty()){ 
            TreeNode nodo=queue.poll(); 
            System.out.print(nodo.val+" "); 
            if (nodo.izquierda!=null){ 
            if (nodo.derecha!= nulo) { 
                cola.oferta(nodo.derecha); 
                cola.oferta(nodo.izquierda);
            }
            } 
        } 
} 
    }

  //查找双亲结点
    public TreeNode getParent(nodo TreeNode){ 
        return findParent(raíz,nodo); 
    } 

    public TreeNode findParent(raíz de TreeNode, nodo de TreeNode){ 
        if (root==null || root==node){ 
            return null; 
        } 
        if (root.left==nodo || root.right==nodo){ 
            return root; 
        } 
        TreeNode padre=findParent(root.left,nodo); 
        if (padre!=null){ 
            return padre; 
        } 
        return findParent(root.right,nodo); 
    } 

    //查找兄弟结点
    public TreeNode getSibling(TreeNode node){ 
        TreeNode parent=getParent(nodo);
        if (padre==null){
            devolver nulo; 
        } 
        if (parent.left==nodo){ 
            return parent.right; 
        }else { 
            return parent.left; 
        } 
    } 


    //查找孩子结点
    public TreeNode[] getChildren(nodo TreeNode){ 
        TreeNode[] niños=new TreeNode[2]; 
        hijos[0]=nodo.izquierda; 
        hijos[1]=nodo.derecha; 
        devolver niños; 
    } 
}