Solucionado (ver solução)
Solucionado
(ver solução)
2
respostas

Ajuda com o furacão Roberta Takenaka

Essa professora é inteligente demais! Eu não consigo acompanhar o ritmo dela!

Alguém me ajuda a entender a Aula 5. Mais especificamente no vídeo Arvore Apresentacao parte 3...

Aos 3:44 ela diz: "É tudo recursivo."

O que é isso?

E se puder comentar o código arquivo arvore.py, pq eu me perdi todo quando ela colocou a função localiza_nodo() nas 3 classes e, pra piorar, chamou essa função dentro da própria função...

Tô confuso!!!

PS: A professora é excelente, tá..? Só que essa aula foi demais pra mim!

Segue o código do arquivo arvore.py :

from lista_duplamente_ligada import ListaDuplamenteLigada

class ListaDeNodos(ListaDuplamenteLigada):

def __init__(self):
    super().__init__()

def imprimir(self, nivel):
    atual = self.inicio
    for i in range(0, self.quantidade):
        atual.conteudo.imprimir(nivel)
        atual = atual.proximo

def localizar_nodo(self, conteudo):
    atual = self.inicio
    for i in range(0, self.quantidade):
        encontrado = atual.conteudo.localizar_nodo(conteudo)
        if encontrado:
            return encontrado
        atual = atual.proximo

class Nodo:

def __init__(self, conteudo):
    self.conteudo = conteudo
    self.pai = None
    self.filhos = None

def __repr__(self):
    return self.conteudo

def imprimir(self, nivel = 0):
    print("{}- {}".format("    "*nivel, self.conteudo))
    if self.filhos:
        self.filhos.imprimir(nivel + 1)

def inserir_filho(self, filho):
    if self.filhos is None:
        self.filhos = ListaDeNodos()
    nodo = Nodo(filho)
    self.filhos.inserir_no_fim(nodo)

def localizar_nodo(self, conteudo):
    if conteudo == self.conteudo:
        return self
    if self.filhos:
        return self.filhos.localizar_nodo(conteudo)

class Arvore:

def __init__(self, conteudo):
    self.raiz = Nodo(conteudo)

def imprimir(self):
    self.raiz.imprimir()

def localizar_nodo(self, conteudo):
    return self.raiz.localizar_nodo(conteudo)

def inserir_nodo(self, pai, filho):
    nodo_pai = self.localizar_nodo(pai)
    if nodo_pai:
        nodo_pai.inserir_filho(filho)
2 respostas
solução!

Olá Vinicius, tudo bem?

Árvores e recursão são assuntos bem complexos mesmo, recomendo sempre rever algumas aulas para ter certeza que compreendeu o conteúdo :)

Agora em relação as suas perguntas:

"É tudo recursivo". O que é isso?

Recursão nada mais é do que uma função que chama a si mesmo, sempre modificando um pouco o parâmetro para quebrar o problema em pedaços menores :)

Vamos observar então a função localizar_nodo que está utilizando a recursão:

def localizar_nodo(self, conteudo):
    atual = self.inicio
    for i in range(0, self.quantidade):
        encontrado = atual.conteudo.localizar_nodo(conteudo)
        if encontrado:
            return encontrado
        atual = atual.proximo

O que estamos fazendo é verificar se encontrarmos o nodo, com a mesma função, agora veja que se não encontramos mudamos o atual para atual.proximo para ver se está nessa parte da árvore, (nessa parte estamos quebrando o problema em etapas menores!).

Agora sim podemos ir para o arvore.py

def localizar_nodo(self, conteudo):
    return self.raiz.localizar_nodo(conteudo)

Observe que é um código bem simples, recebemos um conteúdo para pesquisar e iremos invocar a seguinte função:

def localizar_nodo(self, conteudo):
    if conteudo == self.conteudo:
        return self
    if self.filhos:
        return self.filhos.localizar_nodo(conteudo)

Então veja que aqui o que fazemos é verificar se o que o usuário passou é o elemento inicial (raiz), caso não seja estamos pedindo para ela localizar a função com os filhos, e ai usamos a recursão:

Observe que o filhos da raiz podem ter também outros filhos ( e assim respectivamente) então o que fazemos é :

Suponha que a nossa árvore seja:

Livros
    -Culinária
        -  Bebidas
    -Programacao
        - Python

Quando pedimos para localizar "Python" o que será feito é:

  • Verifica se conteúdo é igual a "Livros" => Falso
  • Pede para o seu filho (Culinária) verificar
  • Culinária verifica se conteúdo é igual a "Culinária" => Falso
  • Culinária pede para o seu filho Bebidas verificar
  • Bebidas verifica se o conteúdo é iguala "Culinária" => Falso
  • Bebidas não tem filho então volta da recursão para Culinária
  • Culinária não tem mais filhos então volta da recursão
  • Agora temos um ponto importante: A recursão vai voltar com none e falar para Livros verificar o próximo Filho (Programação)
  • Programação verifica se o conteúdo é igual a "Livros" => Falso
  • Programação pede para o seu filho Python verificar
  • Finalmente Python verifica que é igual a conteúdo e retorna a si mesmo
  • Nesse momento acaba a função pois já temos o valor

Conseguiu entender? Qualquer coisa estou a disposição :)

Abraços e Bons Estudos!

Olá Geovani, tudo beleza?

Após muito tempo indo e voltando no ciclo:

* ler a sua resposta todos os dias (às vezes mais de uma vez por dia);
* voltar para o meu código;
* pensar bastante;
* sentar no chão gelado agarrando os meus joelhos;
* e ir dormir em posição fetal,

concluí que sou um completo amador nessa parada!

Mas, por incrível que pareça, EU ACHO QUE ENTENDI!!!

Cara, o que vc explicou aqui nessa parte em específico:

Quando pedimos para localizar "Python" o que será feito é:

Verifica se conteúdo é igual a "Livros" => Falso
Pede para o seu filho (Culinária) verificar
Culinária verifica se conteúdo é igual a "Culinária" => Falso
Culinária pede para o seu filho Bebidas verificar
Bebidas verifica se o conteúdo é iguala "Culinária" => Falso
Bebidas não tem filho então volta da recursão para Culinária
Culinária não tem mais filhos então volta da recursão
Agora temos um ponto importante: A recursão vai voltar com none e falar para Livros verificar o próximo Filho (Programação)
Programação verifica se o conteúdo é igual a "Livros" => Falso
Programação pede para o seu filho Python verificar
Finalmente Python verifica que é igual a conteúdo e retorna a si mesmo
Nesse momento acaba a função pois já temos o valor

foi crucial!

QUE AULA!! (palmas lentas aqui)

Parabéns cara, muito didática a sua explicação!

É como se a Renata Takenaka fosse a Maria em "João e Maria" e estivesse em um labirinto. (calma, eu vou tentar explicar essa loucura!)

Ela vai por um caminho do labirinto procurando algo. Mas como ela é genial, ela vai marcando o caminho com as pedras (como João e Maria na história) para não se perder. E quando ela chega numa "rua sem saída ", sem sucesso na sua busca, ela volta pelo caminho marcado e tenta por outro. Repetindo o procedimento por todos os caminhos até encontrar o que procura!!!

É incrível!!! Tô muito empolgado com os meus estudos!

Muito obrigado pela excelente explicação! Abraço.