Java preciso de um método de remover em arvore

[darlan DNYZARTH]

package facema.aulas.arvores;

/**
 *
 * @author Gian Carlos
 */
public class ArvoreBin<T>{
    private No<T> raiz;
    private No<T> esq;
    private No<T> dir;
  
    
    

	
public No<T> inserir(T valor) {
      return inserir(new No<>(valor), raiz);
    }

private No<T> inserir(No<T> novo, No<T> anterior){
    if (raiz == null) {
        raiz = novo;
        return raiz;
    }

    if (anterior != null){
        if (novo.compareTo(anterior) <= 0){
       	    No<T> esq = inserir(novo, anterior.getEsq());
            anterior.setEsq(esq);
        } else if (novo.compareTo(anterior) > 0){
            No<T> dir = inserir(novo, anterior.getDir());
            anterior.setDir(dir);
        } else { 
        return null;
        }
    } else { 
    anterior = novo;
    }
    return anterior;
}
    
 
	
public int contagem(No<T> no){
    if(no == null) {
        return 0;
	}
    return (1 + contagem(no.getEsq()) + contagem(no.getDir()));
}

// Raiz - Esquerda - Direita
public void preOrdem(){
    preOrdem(raiz);
}
	
public void preOrdem(No<T> no){
    if (no != null){
        System.out.println(no.getConteudo());
        preOrdem(no.getEsq());
        preOrdem(no.getDir());
    }
}
	
// Esquerda - Direita - Raiz
public void posOrdem(){
    posOrdem(raiz);
}
	
public void posOrdem(No<T> no){
    if (no != null) {
        posOrdem(no.getEsq());
        posOrdem(no.getDir());
        System.out.println(no.getConteudo());
    }
}
	
// Esquerda - Raiz - Direita
public void emOrdem(){
    preOrdem(raiz);
}
	
	
public void emOrdem(No<T> no){
    if (no != null) {
        emOrdem(no.getEsq());
        System.out.println(no.getConteudo());
        emOrdem(no.getDir());
        }
    }
public T buscar(T procurado){
         No node = new No(procurado);
         
         return buscar(node, raiz);
         
        }
            
        
private T buscar(No procurado, No<T> pai){
    No no = procurado;
    No<T> aux = pai;
            
    if(raiz == null){
        throw new RuntimeException("Arvore vazia!");
                
                
                
    }else{
        if(aux == null){
            throw new RuntimeException("Valor não encontrado!");
                   
        }else if(  aux.compareTo(no) == 0){
            return (T) aux.getConteudo();      
            }else if(no.compareTo(aux) <= 0){
                T temp = buscar(procurado, aux.getEsq());
                return temp;
                }else if(no.compareTo(aux) > 0){
                    T temp = buscar(procurado, aux.getDir());
                    return temp;
                }
            }
            return null; 
        }
}
package facema.aulas.arvores;

/**
 *
 * @author Gian Carlos
 */
public class No <T> {
    
	private T conteudo;
	private No<T> esq;
	private No<T> dir;
	
	public No(T conteudo,No<T> esq, No<T> dir) {
		this.conteudo = conteudo;
                this.dir = dir;
                this.esq = dir;
	}
        public No(T conteudo){
            this.conteudo = conteudo;
            
        }
	
	public T getConteudo() {
		return conteudo;
	}
	public void setConteudo(T conteudo) {
		this.conteudo = conteudo;
	}
	public No<T> getEsq() {
		return esq;
	}
	public void setEsq(No<T> esq) {
		this.esq = esq;
	}
	public No<T> getDir() {
		return dir;
	}
	public void setDir(No<T> dir) {
		this.dir = dir;
	}
	
	public int compareTo(No<T> o) {
		Professor p = (Professor) conteudo;
		Professor p1 = (Professor) o.getConteudo();
		return p.compareTo(p1);
	}
}
package facema.aulas.arvores;

/**
 *
 * @author Gian Carlos
 */
public class Professor implements Comparable<Professor>{
    
    private String nome;
    private double salario;
    
    public Professor(Professor prof){
        
    }
    
    public Professor(String nome, double salario) {
		// TODO Auto-generated constructor stub
		this.nome = nome;
		this.salario = salario;
	}
	
	public String getNome() {
		return nome;
	}
	public void setNome(String nome) {
		this.nome = nome;
	}
	public double getSalario() {
		return salario;
	}
	public void setSalario(double salario) {
		this.salario = salario;
	}
	
        @Override
	public String toString() {
		return "(" + nome + ", " + salario + ")";
	}

	@Override
	public int compareTo(Professor o) {
		// TODO Auto-generated method stub
		return nome.compareTo(o.getNome());
	}
    
}
package facema.aulas.arvores;

/**
 *
 * @author Gian Carlos
 */
public class TesteArvore {
    public static void main(String[] args) {
         ArvoreBin<Professor> a = new ArvoreBin<>();
        Professor p1 = new Professor("Helio", 10000), p2 = new Professor("Marcelo", 9999),
	p3 = new Professor("Leoncio", 9000), p4 = new Professor("Italo", 4000);
	a.inserir(p1);
	a.inserir(p2);
	a.inserir(p3);
        a.inserir(p4);
        
        /*
        *
        *         Helio
        *              \
        *               Marcelo
        *              /
        *          Leoncio
        *           /
        *        Italo
        *
        */
	
        // Raiz - Esquera - Direita: Helio, Marcelo, Leoncio, Italo
	System.out.println("PreOrdem");
        a.preOrdem();
        
        // Esquerda - Direita - Raiz: Italo, Leoncio, Marcelo, Helio 
	System.out.println("PosOrdem");
	a.posOrdem();
        
        // Esquerda - Raiz - Direita: Italo, Leoncio, Marcelo, Helio
	System.out.println("EmOrdem");
	a.posOrdem();
        
        System.out.println("Buscar Professor:");
        System.out.println(a.buscar(p2));
    }
}

Boa tarde estou desenvolvendo um trabalho de arvores e estou com dificuldade de desenvolver o método de remover e gostaria de ajuda