29/10/2023

Percurso em árvores
• É o processo de visitar cada nó na árvore exatamente uma vez. A travessia pode ser
interpretada como colocar todos os nós em uma linha ou linearização de uma árvore.
• Para uma árvore com 𝑛 nós, há 𝑛! percursos possíveis
• A maioria é caótica e inútil
• Possíveis percursos na árvore ao lado (de 8! = 40320 percursos):
• 2, 10, 12, 20, 13, 25, 29, 31
• 29, 31, 20, 12, 2, 25, 10, 13
• 13, 31, 12, 2, 10, 29, 20, 25
• Restringimos o estudo a apenas duas classes de percursos
• Percurso em Extensão (ou Largura) (Breadth-First Traversal)
• Percurso em Profundidade (Depth-First Traversal)

Percurso em Extensão (Breadth-First Traversal)

• Existem 4 possibilidades de percurso em extensão
• Envolve visitar cada nó a partir do nível mais baixo ou mais alto
• A progressão ocorre nível a nível, com visitas da esquerda para
a direita ou da direita para a esquerda
• O percurso de cima para baixo e da esquerda para a direita produz:
13, 10, 25, 2, 12, 20, 31, 29 template<class T>
void BST<T>::breadthFirst() {
• A implementação desse percurso é direta quando se utiliza uma Queue<BSTNode<T>*> queue;
BSTNode<T> *p = root;
fila. if (p != 0) {
• Em um percurso de cima para baixo e da esquerda para a queue.enqueue(p);
direita, após visitar um nó, seus filhos são colocados no final while (!queue.empty()) {
p = queue.dequeue();
da fila. visit(p);
• O nó no início da fila é visitado em seguida. if (p->left != 0)
queue.enqueue(p->left);
• Ao fazer isso, garante-se que todos os nós em um if (p->right != 0)
determinado nível n sejam visitados antes de passar para o queue.enqueue(p->right);
próximo nível n + 1. }
}
}

10
 29/10/2023

Percurso em Profundidade (Depth-First Traversal)

• Processo de percurso em profundidade: template<class T>
void BST<T>::inorder(BSTNode<T> *p) {
• Procede o máximo possível para a esquerda (ou direita) if (p != 0) {
• Em seguida, retrocede até o primeiro cruzamento inorder(p->left);
visit(p);
• Após o cruzamento, avança um passo para a direita (ou esquerda) }
inorder(p->right);

• Novamente, avança o máximo possível para a esquerda (ou direita) }

• Esse processo é repetido até que todos os nós sejam visitados template<class T>
• A definição que não especifica claramente o momento das visitas aos nós void BST<T>::preorder(BSTNode<T> *p) {
if (p != 0) {

• Três tarefas principais envolvidas no percurso em profundidade são: visit(p);

preorder(p->left);
• V - Visitar um nó }
preorder(p->right);

• L - Percorrer a sub-árvore esquerda }

• R - Percorrer a sub-árvore direita template<class T>

void BST<T>::postorder(BSTNode<T>* p) {
• Combinações possíveis para percurso em profundidade: VLR, LVR, if (p != 0) {
LRV, VRL, RVL, RLV postorder(p->left);
postorder(p->right);
• Em geral, usa-se aqueles que a ordem é da esquerda para a direita visit(p);
}
• VLR—percurso de árvore em pré-ordem (preorder tree traversal) }
• LVR—percurso de árvore em in-ordem (inorder tree traversal)
• LRV—percurso de árvore em pós-ordem (postorder tree traversal)

11

Percurso em Profundidade (Depth-First Traversal)

• Percurso de árvore em in-ordem (inorder tree traversal) template<class T>
void BST<T>::inorder(BSTNode<T> *p) {
• Percorre a sub-árvore da esquerda if (p != 0) {
inorder(p->left);
• Visita o nó visit(p);
inorder(p->right);
• Percorre a sub-árvore da direita }
}

• Se a visita incluir a impressão do valor do nó, qual seria a saída do programa?

• 1, 4, 15, 16, 20, 25

12
 29/10/2023

Percurso em Profundidade (Depth-First Traversal)

• Percurso de árvore em in-ordem (inorder tree traversal)

13

Remoção em Árvore Binária de Busca

• O nível de complexidade na execução da operação depende da posição do nó a ser
excluído na árvore.

• Três casos:
• O nó é uma folha
• O nó tem um filho
• O nó tem dois filhos

14
 29/10/2023

Remoção em Árvore Binária de Busca

• Três casos:
• O nó é uma folha
• O ponteiro apropriado de ascendente é definido como NULL e o nó é removido (desalocado da
memória)
• O nó tem apenas um filho
• O ponteiro do nó ascendente é redefinido para apontar para o filho do nó a ser removido
• O nó tem dois filhos
• Remoção por fusão (merging)
• Remoção por cópia

15

Remoção por fusão

• Solução que move uma das duas sub-árvores do nó a ser removido para que seja anexada
ao pai do nó a ser removido.
• Ideia: Encontrar, na sub-árvore esquerda, o nó com maior valor e torná-lo o pai da sub-
árvore direita
• Simetricamente, pode-se tomar o nó com menor valor na sub-árvore da direita e torná-lo pai
da sub-árvore esquerda

16
 29/10/2023

Remoção por fusão

node.left
node
node.left node.right 10 O algoritmo para exclusão por
15
fusão pode resultar no aumento
10 Remover 5 11 da altura da árvore. Em alguns
30
15 node.right casos, a nova árvore pode estar
5 11 12
20 40 altamente desequilibrada.
12 30
Por vezes, a altura pode ser
20 40 reduzida. Esse algoritmo não é
node.left ineficiente, mas está longe de ser
node
perfeito. Há a necessidade de um
node.left node.right 10 node.right
15 algoritmo que não dê à árvore a
5 chance de aumentar sua altura ao
10 30 30
Remover excluir um de seus nós.
5 20 40 15 4 7 20 40

4 7

17

Remoção por cópia

• Se o nó tiver dois filhos, o problema pode ser reduzido a um de dois casos simples:
• o nó é uma folha ou
• o nó tem apenas um filho não vazio
• Ideia: Encontrar, na sub-árvore esquerda, o nó com maior valor e copiar esse valor no nó
que está sendo “deletado”
• Remove uma chave k1 substituindo-a por outra chave k2 e, depois, remove o nó que
contém k2.

18
 29/10/2023

Remoção por cópia

• Esse algoritmo não aumenta a altura da árvore, mas
ainda causa um problema se for aplicado muitas
vezes junto com a inserção.
• O algoritmo é assimétrico: ele sempre exclui o nó do
predecessor imediato do nó, reduzindo a altura da
sub-árvore esquerda e deixando a sub-árvore direita
inalterada.
• A sub-árvore direita pode crescer após inserções
posteriores e, se ocorrer uma exclusão, a altura da
árvore direita permanecerá a mesma. Depois de
muitas inserções e deleções, a árvore torna-se
desequilibrada à direita.
• Solução: Alternadamente excluir o predecessor do nó
da sub-árvore esquerda e excluir o sucessor da sub-
árvore direita

19