Árvores Binárias, Notas de estudo de Automação

Baixe Árvores Binárias e outras Notas de estudo em PDF para Automação, somente na Docsity!

ENGENHARIA DE CONTROLE E AUTOMAÇÃO

FACULDADE PITÁGORAS

Jadson Santos Gonçalves

ESTRUTURA DE DADOS NÃO LINEARES

E ÁRVORES BINÁRIAS

DIVINÓPOLIS-MG

SUMÁRIO

1. INTRODUÇÃO...............................................................................................

1.1. ESTRUTURAS DE DADOS NÃO LINEARES :ÁRVORES

1.2. ÁRVORE..................................................................................................

1.3. DEFINIÇÃO E

TERMINOLOGIA......................................................................................

1.4. ÁRVORES

BINÁRIAS................................................................................................

1.5. PROPRIEDADES.....................................................................................

1.6. MÉTODOS DE

TRAVESSIA.............................................................................................

1.7. VISITA

SIMÉTRICA..............................................................................................

1.8. VISITA-PREORDEM

1.9. VISITA EM

POSORDEM............................................................................................

1.10. VISITA POR

NÍVEIS.....................................................................................................

1.11. NOTA 1.........................................................................................

1.12. NOTA 2.........................................................................................

1.13. NOTA 3.........................................................................................

1.14. APLICAÇÕES...............................................................................

1.15. REFERÊNCIAS.............................................................................

ESTRUTURAS DE DADOS NÃO LINEARES :ÁRVORES

Estruturas lineares (pilha e fila), isto é, estruturas que guardam colecções de objetos que são acedidos sequencialmente. Efetivamente são chamadas lineares porque cada objeto tem um único sucessor.

Em muitas aplicações a organização dos objetos apresenta-se não linear, dado que qualquer membro pode apresentar múltiplos sucessores.

ÁRVORES

Neste tipo de estruturas os elementos não se ligam entre si através de uma relação anterior-seguinte (caso das estruturas lineares), mas existe uma relação organizacional mais rica, uma relação hierárquica, são portanto estruturas hierarquizadas. Este tipo de estrutura representa por exemplo, o organigrama de uma empresa, uma árvore genealógica, ...um livro, por exemplo, também podemos considerá-lo como estruturado em árvore, ver a figura abaixo:

Definição e Terminologia

A terminologia deste tipo de estrutura é uma terminologia intuitiva que se baseia em árvores de família, com os termos "pai", "filho", "ascendentes", "descendentes"... Árvore é assim um tipo abstracto de dados que guarda os elementos (nós) hierarquicamente. Na representação gráfica de árvores os nós ligam-se por ramos....

Prefácio

1.1 1.2 1.

Capítulo 1 Capítulo 2 Capítulo 3

Parte A

4.1 4.

Capítulo 4 Capítulo 5 Capítulo 6

Parte B Referências

Livro

Com excepção do elemento de topo, cada elemento tem um elemento pai e zero ou mais elementos filhos. O elemento de topo é designado por raiz. Assim, este elemento não tem elemento pai nem obviamente ascendentes.

Por sua vez os elementos que não possuem filhos são designados por folhas. Os outros nós da árvore dizem-se interiores.

Por sua vez cada elemento numa árvore é a raiz da subárvore que é definida pelo nó e todos os descendentes do nó.

Exemplo: descendentes do nó 70 são 60 e 75.

O movimento de um nó para os seus descendentes faz-se através de um único caminho. Os ascendentes de um nó X são todos os nós que existem no caminho desde esse nó até à raiz. Exemplo: ascendentes do nó 85 são 90 e 80.

Define-se ainda por profundidade de um nó o número de ramos existentes no caminho entre o nó e a raiz, ou recorrendo a uma definição recursiva teremos:

Profundidade do nó (X) = 0 se X é raiz 1 + Profundidade do nó (pai(X)), nos outros casos

Exemplo: Profundidade do nó 85 é 2.

Entende-se por altura de uma árvore a máxima profundidade apresentada pelos nós. Chamamos grau de um nó ao número de filhos que esse nó tem. Chamamos grau de uma árvore ao máximo dos graus dos seus nós.

Dizemos que uma árvore é ordenada se existe uma ordem entre os filhos de cada nó, de tal maneira que podemos identificar os filhos de um nó como sendo o primeiro, o segundo, ... e essa ordem é importante, não é indiferente, para a definição da nossa estrutura. Tal ordem é determinada pelo uso que pretendemos fazer da árvore.

Visita simétrica

A forma de percorrer os nós da árvore de forma simétrica corresponde a visitar simètricamente a subárvore esquerda seguida da visita ao nó (por exemplo, escrever conteúdo do nó ou qualquer outra operação que pretendamos sobre esse nó), seguida da visita simétrica à subárvore direita.

Assim o algoritmo capaz de executar o que foi dito, poderá ser recursivo e traduzir-se-á da seguinte forma:

Algoritmo recursivo: Visita-Simétrica (arvore) Se (arvore não nula) Então Visita-Simétrica (subárvore esquerda) Visita-Nó Visita-Simétrica (subárvore direita) Fim-se Fim Algoritmo

Se a Visita-Nó for escrever o conteúdo do nó, ao aplicarmos este algoritmo à árvore acima, obteremos a seguinte sequência de valores : 60 70 75 80 85 90 95

Poder-se-ia usar um algoritmo iterativo, em vez do anteriormente descrito, mas nesse caso teríamos que usar uma estrutura auxiliar do tipo stack, onde seriam colocados os apontadores para os nós da árvore que percorremos quando descemos pela subárvore esquerda. Depois far-se-á pop da stack para visitarmos a subárvore direita.

Algoritmo iterativo Visita-simétrica r=raiz Repete Enquanto ( r=/= Nulo ) // descer pelos apontadores da esquerda e colocar os nós na stack Push (r) r=r->esq Fenquanto Se (stack não vazia) // tira o último nó da stack, visita-o e avança para a subárvore direita Então r=pop

Visita-Nó r=r->dir Fse Até (stack vazia e r=Nulo) Fim Algoritmo

Visita em preordem

A forma de percorrer os nós da árvore em preordem, corresponde a visitar o nó, seguidas das visitas em preordem da subárvore esquerda e da subárvore direita.

Algoritmo recursivo: Visita-Preordem (arvore) Se arvore não nula Então Visita-Nó Visita-Preordem (subárvore esquerda) Visita-Preordem (subárvore direita) Fim-se Fim Algoritmo

Se a Visita-Nó for escrever o conteúdo do nó, ao aplicarmos este algoritmo à árvore acima, obteremos a seguinte sequência de valores : 80 70 60 75 90 85 95

Do mesmo modo que no caso anterior este tipo de percorrer a árvore binária pode ser feito utilizando um algoritmo iterativo como abaixo se indica:

Algoritmo iterativo Visita-Preordem r=raiz Repete Enquanto ( r=/= Nulo ) // descer pelos apontadores da esquerda e colocar os nós na stack Visita-Nó Push (r) r=r->esq Fenquanto Se (stack não vazia) // tira o último nó da stack, avança para a subárvore direita Então r=pop r=r->dir Fim-se Até (stack vazia e r=Nulo) Fim Algoritmo

Fim-se Fenquanto Fim Algoritmo

NOTA 1

Toda a árvore n-ária é possível converter em árvore binária Para fazer isto basta seguir a seguinte regra: na árvore binária o nó à esquerda é o que na árvore n-ária era o filho mais à esquerda, se existirem filhos, e o nó à direita é o que na árvore n-ária era o irmão seguinte (se existir).

Podemos considerar o seguinte algoritmo para executar a referida conversão, desde que os elementos da árvore n-ária sejam dados em preordem. Para converter árvore da figura acima aplicando o algoritmo que a seguir se descreve, os conteúdos dos nós deveriam ser dados na seguinte sequência : A, B, F, G, C, D, H, I, J, E e ao mesmo tempo indicado o nível em que cada nó se encontra na árvore original.

Algoritmo Conversão n-ária-binária -cria nó raiz -push (raiz, nível) // usar-se-á uma stack auxiliar Repete Ler nó corrente (conteúdo e nível) Cria nó para árvore binária e atribui-lhe o conteúdo Se nível do nó corrente > nível do nó da stack Então Liga apontador esquerdo do nó da stack (pai) ao nó criado Senão Retira da stack todos os nós com nível > que o nível do nó criado Liga apontador direito do nó da stack ao nó criado

Retira da stack Fse Push(nó criado,nível) Até não haver mais nós. Fim Algoritmo

NOTA 2

A implementação de árvores binárias pode fazer-se usando alocação dinâmica de memória, em que será reservado espaço na memória para colocar cada nó. Cada nó será constituído por um campo informação e dois campos do tipo apontador para nó.

Pode ainda fazer-se a implementação em memória estática utilizando 3 vectores, um vector com a informação dos nós da árvore e outros dois, vector esquerdo e vector direito que contêm respectivamente, os índice onde se encontram no vector informação o nó que está à esquerda e o nó que está à direita.

Implementação dinâmica Implementação estática

Acima encontram-se representadas graficamente as duas implementações da mesma árvore.

NOTA 3

Neste tipo de estruturas (arvores nárias e árvores binárias), embora se utilizem em algumas casos, como é indicado no ponto referente a aplicações, não trazem qualquer

class Nodo { public: T * info; Nodo *esq; Nodo *dir; Nodo(); Nodo(const T & e); Nodo(const T & e,Nodo *esq1,Nodo *dir1); };

template Nodo::Nodo() { info=NULL; esq=dir=NULL; }

template Nodo::Nodo(const T & e) { info = new T(e); esq=dir=NULL; }

template *Nodo::Nodo(const T & e,Nodo esq1,Nodo dir1) { info=new T(e); esq=esq1; dir=dir1; } / Fim da classe Nodo */

/* **************************************************** */

/* Definicao da classe arvBinaria - representa a arvore binaria */ template class arvBinaria { private : Nodo *raiz; void destroiArv(Nodo * raiz); void preOrdem(Nodo *raiz) const; void postOrdem(Nodo *raiz) const; void ordemSimetrica(Nodo *raiz) const; Nodo *eliminar(const T & x,Nodo *rz,int &enc); Nodo *pesquisar(const T & x,Nodo *rz) const; public: arvBinaria(); ~arvBinaria();

bool vazia() const; void preOrdem() const { preOrdem(this->raiz); return; } void postOrdem() const { postOrdem(this->raiz); return; } void ordemSimetrica() const { ordemSimetrica(this->raiz); return; } void fazerArv(const T & elem,arvBinaria & a1,arvBinaria & a2); bool pesquisar(const T & x) const; arvBinaria & eliminar(const T & x); };

template arvBinaria::arvBinaria() { raiz = NULL; }

template arvBinaria::~arvBinaria() { destroiArv(raiz); }

template void arvBinaria::destroiArv(Nodo * raiz) { if (raiz !=NULL) { destroiArv(raiz->esq); destroiArv(raiz->dir); delete raiz; } }

template bool arvBinaria::vazia() const { return (raiz==NULL); }

template *void arvBinaria::preOrdem(Nodo raiz) const { if (raiz!=NULL) { cout<< *(raiz->info) << endl; preOrdem(raiz->esq); preOrdem(raiz->dir);

Nodo * n; if(rz) { if(*(rz->info)==x) // a classe com que vai instanciar T terá que ter definido o //operador == return rz; n=pesquisar(x, rz->esq); if(n==NULL) return pesquisar(x, rz->dir); return n; } else return NULL;

}

template arvBinaria& arvBinaria::eliminar(const T & x) { int enc=0; raiz=eliminar(x,raiz,enc); return *this; }

template Nodo arvBinaria::eliminar(const T & x,Nodo rz,int &enc) { if(rz==NULL) return rz; if(*(rz->info)==x) { destroiArv(rz); enc=1; return NULL; }

rz->esq=eliminar(x,rz->esq,enc); if (enc==0) rz->dir=eliminar(x,rz->dir,enc); return rz; }

REFERÊNCIAS

PRF. Adriano, J. O. C. de. Apostila árvores binárias. Divinópolis, 2000. http://equipe.nce.ufrj.br/adriano/c/apostila/arvore.htm www.dei.isep.ipp.pt