/// <summary>
/// Cria um no externo, sem filhos
/// </summary>
/// <param name="noPai"></param>
/// <returns></returns>
public static NodoArvore CriaNoExterno(NodoArvore noPai)
{
NodoArvore no = new NodoArvore();
no.SetNoPai(noPai);
return(no);
}
/// <summary>
/// Insere um valor na árvore. não aceita valores repetidos, se o valor já existir ele devolve falso
/// </summary>
/// <param name="valor"></param>
/// <returns> retorna falso se o valor já existir e verdadeiro se o valor for inserido com sucesso</returns>
public bool Insere(Animal valor) // insere um valor int
{
NodoArvore no_aux;
if (qtdeNodosInternos == 0) // árvore vazia!
{
// árvore vazia, devemos criar o primeiro Nodo, que será a raiz
no_aux = new NodoArvore();
raiz = no_aux;
}
else
{
// localiza onde deve ser inserido o novo nó.
no_aux = PesquisaValor(valor.Nome, raiz);
if (no_aux.EhInterno())
{
throw new Exception("Este animal já existe na árvore!!!!");
}
}
// este era um Nodo externo e portanto não tinha filhos.
// Agora ele passará a ser interno, portanto devemos criar outros 2
// nodos externos (filhos) para ele.
no_aux.SetValor(valor);
no_aux.SetNoEsquerda(NodoArvore.CriaNoExterno(no_aux));
no_aux.SetNoDireita(NodoArvore.CriaNoExterno(no_aux));
qtdeNodosInternos++;
return(true);
}
private void PercursoInterfixadoIdade(NodoArvore no, ref Lista list)
{
if (no.EhExterno())
{
return;
}
PercursoInterfixadoIdade(no.GetNoEsquerda(), ref list);
list.AdicionarEmOrdem(no.GetValor()); // Se for do mesmo tipo do objeto passado como parametro, ou herdar dele ou implementar ele
PercursoInterfixadoIdade(no.GetNoDireita(), ref list);
}
private void ExcluiSemNodoExterno(NodoArvore noQueSeraApagado)
{
//encontra o nodo substituto
NodoArvore NodoSubstituto = PesquisaNodoInternoInterfixado(noQueSeraApagado.GetNoDireita());
Console.Write("Nodo substituto: " + NodoSubstituto.GetValor().Nome);
//Altera o valor do nodo que será removido pelo valor do nodo substituto
noQueSeraApagado.SetValor(NodoSubstituto.GetValor());
//Remove o nodo substituto
ExcluiComNodoExterno(NodoSubstituto);
}
/// <summary>
/// Percorre toda a arvore em sentido crescente a partir de um nodo, adicionada na lista especificada
/// de maneira recursiva todos os itens da arvore que: são do mesmo Type que o Type especificado em
/// tipo, ou herdam do tipo ou implementam o tipo
/// </summary>
/// <param name="no">Nodo que será analisado</param>
/// <param name="list">Lista onde será armazenado os dados</param>
/// <param name="tipo">typeof() da classe ou interface para procurar</param>
private void PercursoInterfixado(NodoArvore no, ref Lista list, Type tipo)
{
if (no.EhExterno())
{
return;
}
PercursoInterfixado(no.GetNoEsquerda(), ref list, tipo);
if (no.GetValor().GetType() == tipo || no.GetValor().GetType().IsSubclassOf(tipo) ||
no.GetValor().GetType().GetInterfaces().Contains(tipo))
{
list.InserirNoFim(no.GetValor());// Se for do mesmo tipo do objeto passado como parametro, ou herdar dele ou implementar ele
}
PercursoInterfixado(no.GetNoDireita(), ref list, tipo);
}
/// <summary>
/// Pesquisa um valor na arvore binaria, e caso encontrado retorna ele
/// </summary>
/// <param name="nome">nome do animal procurado</param>
/// <returns></returns>
public Animal Pesquisar(string nome)
{
NodoArvore no_aux = new NodoArvore();
no_aux = PesquisaValor(nome, raiz);
if (no_aux.EhExterno())
{
throw new Exception("Animal não encontrado!");
}
else
{
return(no_aux.GetValor());
}
}
/// <summary>
/// Pesquisa o próximo nodo Interno seguindo o percurso interfixado.
/// </summary>
/// <param name="no"></param>
/// <returns></returns>
private NodoArvore PesquisaNodoInternoInterfixado(NodoArvore no)
{
if (no.EhExterno())
{
return(null);
}
NodoArvore retorno = PesquisaNodoInternoInterfixado(no.GetNoEsquerda());
if (retorno == null)
{
return(no);
}
else
{
return(retorno);
}
}
/// <summary>
/// Pesquisa um nodo na árvore e devolve o nodo. Caso não encontre, devolve o nodo
/// externo onde a pesquisa parou.
/// </summary>
/// <param name="valor"></param>
/// <param name="no"></param>
/// <returns></returns>
private NodoArvore PesquisaValor(string nome, NodoArvore no)
{
if (no.EhExterno())
{
return(no); // não encontrou
}
else if (no.GetValor().Nome == nome)
{
return(no);
}
else if (nome.CompareTo(no.GetValor().Nome) >= 1)
{
return(PesquisaValor(nome, no.GetNoDireita()));
}
else
{
return(PesquisaValor(nome, no.GetNoEsquerda()));
}
}
/// <summary>
/// Remove um valor da árvore
/// </summary>
/// <param name="valor"></param>
public void Remove(string nome)
{
//primeiro, procuramos o nodo que tem o valor:
NodoArvore noQueSeraApagado = PesquisaValor(nome, raiz);
if (noQueSeraApagado == null || noQueSeraApagado.EhExterno())
{
throw new Exception("Animal não existe na árvore");
}
else
{
// um dos filhos é um nó externo
if (noQueSeraApagado.GetNoEsquerda().EhExterno() ||
noQueSeraApagado.GetNoDireita().EhExterno())
{
ExcluiComNodoExterno(noQueSeraApagado);
}
else
{
ExcluiSemNodoExterno(noQueSeraApagado);
}
}
}
/// <summary>
/// Exclui um nodo que abaixo dele possua, ao menos, 1 nodo exteno.
/// </summary>
/// <param name="noQueSeraApagado"></param>
private void ExcluiComNodoExterno(NodoArvore noQueSeraApagado)
{
qtdeNodosInternos--;
//descobre quem será o nodo que irá ficar no lugar do que foi apagado
NodoArvore nodo_substituto;
if (noQueSeraApagado.GetNoEsquerda().EhInterno())
{
nodo_substituto = noQueSeraApagado.GetNoEsquerda();
}
else
{
nodo_substituto = noQueSeraApagado.GetNoDireita();
}
// substitui o apagado pelo novo nodo
NodoArvore PaiNodoApagado = noQueSeraApagado.GetNoPai();
//altera o pai do novo substituto
nodo_substituto.SetNoPai(PaiNodoApagado);
//o pai do nodo substituto também deve ter sua referência de filho corrigida.
//mas primeiro precisamos saber o no apagado er a raiz, que neste caso não tem pai.
if (PaiNodoApagado != null)
{
if (PaiNodoApagado.GetNoDireita() == noQueSeraApagado)
{
PaiNodoApagado.SetNoDireita(nodo_substituto);
}
else
{
PaiNodoApagado.SetNoEsquerda(nodo_substituto);
}
}
else
{
raiz = nodo_substituto;
}
}
public Boolean NoEhRaiz(NodoArvore no)
{
return(no.GetNoPai() == null);
}
public void SetNoEsquerda(NodoArvore no)
{
no_esquerda = no;
}
public void SetNoDireita(NodoArvore no)
{
no_direita = no;
}
public void SetNoPai(NodoArvore no)
{
no_pai = no;
}