1
resposta

Árvore Binária Recursiva

Amigos estou tendo problema para resolver este exercicio, e nao sei mais como fazer... cheguei implementar a arvore com recursividade, mas agora dessa forma deixando o no como vazio e algumas folhas com numero... nao estou conseguindo montar a logica com recursividade para fazer isso, e depois ter que somar.... Podem me ajudar ?

No.java

public class No {

    public int valor;
    public No direito;
    public No esquerdo;

    public No(int valor) {
        this.valor = valor;
    }
}

ArvoreBinaria.java

public class ArvoreBinaria {

    private No raiz;

    public void inserir(int valor) {
        if (raiz == null) {
            raiz = new No(valor);
        } else {
            No novo = new No(valor);
            inserir(raiz, novo);

        }

    }

    private void inserir(No arvore, No novo) {
        if (novo.valor > arvore.valor) {
            if (arvore.direito == null) {
                arvore.direito = novo;
            } else {
                inserir(arvore.direito, novo);
            }
        } else {
            if (arvore.esquerdo == null) {
                arvore.esquerdo = novo;
            } else {
                inserir(arvore.esquerdo, novo);
            }
        }
    }

EXERCÍCIO

  • Uma arvore tem nos;
  • Um nó pode ou não ter outros nós;
  • Um nó, não folha, tem sempre um nó do lado direito e outro do lado esquerdo
  • As folhas não tem nós abaixo;
  • As folhas têm associado um número inteiro

A figura seguinte representa 3 instancias de arvores binarias

Image and video hosting by TinyPic

Pretende-se implementar um algoritmo em Java que permita a contrução de instância deste tipo. Deverá ter um método que devolva a soma da árvore, ou seja a soma das folhas.

Dicas: - Um nó, não folha, tem sempre um nó à esquerda e um nó a direita - Após a contrução de um nó, será possivel adicionar outros nós - Recursividade - Não usar tipo complexos de Java (Hashmaps, Lists e etc)

1 resposta

Oi, amigo.

Não entendi a dificuldade. Se for o caso da função soma, você tem que fazer um backtracking do valor que deve ser retornado, ou seja, uma variável que irá ir até o fundo da árvore e retornar somando, nó a nó, o valor desejado.

Estou tentando explicar aqui o conceito pq não quero entregar o código de mão beijada. :P Mas se você realmente quiser, fiz a implementação aqui:

public int soma(No pointer) {

        if(pointer == null)
            return 0;
        else {
            int soma = 0;
            soma += soma(pointer.esquerdo);
            soma += soma(pointer.direito);
            soma += pointer.valor;
            return soma;
        }
    }

Qualquer dúvida, estamos aí!