Percursos de árvore binária

Gere uma árvore binária de busca e acompanhe passo a passo os percursos em pré-ordem, em ordem ou em pós-ordem com uma função recursiva em C++.

Tudo é simulado neste navegador; nada é enviado a nenhum servidor.

Visita o nó, depois a subárvore esquerda e em seguida a direita.

A função é chamada com o nó 60

A função é chamada com o nó 60

Árvore binária

60458568215532

Saída

Nenhum nó foi visitado ainda

  • Não visitado
  • Em execução
  • Na pilha
  • Visitado

Passo 1 / 44

Código

#include <iostream>
using namespace std;
class Node { // Um nó guarda seu valor e ponteiros para seus dois filhos
private: // Atributos privados: só os métodos acessam
int value;
Node* left;
Node* right;
public:
Node(int v) : value(v), left(nullptr), right(nullptr) {}
int getValue() const { return value; }
Node* getLeft() const { return left; }
Node* getRight() const { return right; }
void setLeft(Node* n) { left = n; }
void setRight(Node* n) { right = n; }
};
void preorder(Node* node) { // Percorre a subárvore com raiz em node
if (node == nullptr) return; // Caso base: uma subárvore vazia não tem nada a visitar
cout << node->getValue() << " "; // Visita o nó: processa seu valor
preorder(node->getLeft()); // Percorre a subárvore esquerda
preorder(node->getRight()); // Percorre a subárvore direita
} // Retorna ao chamador
Node* insert(Node* root, int v) { // Insere v na árvore de busca e devolve a raiz
if (root == nullptr) return new Node(v); // Posição vazia: o novo nó fica aqui
if (v < root->getValue()) // Valores menores vão para a esquerda e maiores para a direita
root->setLeft(insert(root->getLeft(), v));
else
root->setRight(insert(root->getRight(), v));
return root;
}
Node* buildTree() { // Constrói a árvore inserindo os valores um a um
int values[] = {60, 45, 85, 68, 21, 55, 32}; // Os valores da árvore exibida, na ordem de inserção
Node* root = nullptr;
for (int v : values) root = insert(root, v);
return root;
}
int main() {
Node* root = buildTree(); // A árvore da animação, já construída
preorder(root); // Primeira chamada, a partir de main
cout << endl; // Fim do percurso
return 0;
}

Esta ferramenta gera uma árvore binária de busca (BST) com valores aleatórios e a percorre passo a passo com uma função recursiva em C++. Você escolhe pré-ordem, em ordem ou pós-ordem e vê na mesma árvore quando cada nó é visitado: antes dos filhos, entre eles ou depois deles. Os nós são coloridos por estado (não visitado, em execução, na pilha ou visitado), uma faixa de saída mostra os valores na ordem de visita e o código destaca a linha em execução. As chamadas com nullptr também são exibidas, o caso base que interrompe a recursão. Você pode mudar o tamanho de 3 a 15 nós e gerar outra árvore. Tudo é simulado no seu navegador.

Como usar

  1. Escolha o percurso: Pré-ordem, Em ordem ou Pós-ordem.
  2. Ajuste o tamanho da árvore com o controle deslizante ou clique em Gerar nova árvore; a animação volta ao primeiro passo.
  3. Clique em Reproduzir ou avance com os botões de passo anterior e seguinte, e altere a velocidade se precisar.
  4. Observe os nós coloridos, a faixa de saída com os valores visitados e a linha de código C++ destacada.

Perguntas frequentes

O que é uma árvore binária e o que é uma árvore binária de busca?
Uma árvore binária é uma estrutura em que cada nó tem no máximo dois filhos, esquerdo e direito. Em uma árvore binária de busca (BST), os valores da subárvore esquerda também são menores que o nó e os da direita são maiores.
Qual é a diferença entre pré-ordem, em ordem e pós-ordem?
O que muda é o momento em que o nó é visitado em relação aos filhos. Na pré-ordem visita-se primeiro o nó e depois as subárvores esquerda e direita; na ordem simétrica, a subárvore esquerda, o nó e a subárvore direita; na pós-ordem, a esquerda, a direita e por último o nó. A pré-ordem serve para copiar uma árvore, a ordem simétrica para ler uma BST em ordem e a pós-ordem para liberar ou avaliar uma árvore, pois os filhos são processados antes do pai.
Por que o percurso em ordem de uma BST sai ordenado?
Porque em uma BST tudo o que está à esquerda de um nó é menor e tudo o que está à direita é maior. Visitar a subárvore esquerda, depois o nó e depois a subárvore direita produz os valores do menor para o maior.
Como implementar um percurso recursivo em C++?
Com uma função que recebe um ponteiro para um nó. Se o ponteiro for nullptr, ela retorna sem fazer nada: esse é o caso base. Caso contrário, visita o nó e chama a si mesma com o filho esquerdo e o filho direito, na ordem que o percurso exige.

Ferramentas relacionadas