Árvores

1. Árvores ATAI

2. Arvores • Árvore é um conceito não linear da ciência da computação. • Árvore produz uma organização natural para os dados e está presente nos sistemas de arquivos, interfaces gráficas do utilizadores, base de dados, sites e em outros programas de computador. • As relações numa árvore são hierárquicas com alguns objectos "acima" e outros "abaixo". • A principal terminologia para a estrutura de dados árvore vem de árvores genealógicas, com os termos: pai, filho, ascendente e descendente.

3. Exemplo de estrutura em forma de Arvore

4. TAD Árvore Exemplo de uma árvore representando a estrutura de uma empresa fictícia • TAD que armazena elementos hierarquicamente, isto é: • Com excepção do elemento do topo, cada elemento numa árvore tem um elemento ascendente (pai) e zero ou mais elementos descendentes (filhos). • A representação visual de uma árvore normalmente é feita com os elementos dentro de ovais ou rectângulos, e as relações entre pais e filhos representadas através de linha rectas. • O elemento do topo é chamado de raiz da árvore, mas é mostrado graficamente como o elemento mais alto, com os demais elementos conectados abaixo (o oposto da árvore botânica).

5. Terminologia e Propriedades Básicas • Uma árvore T é um conjunto de nós armazenando elementos numa relação pai-filho com as seguintes propriedades: • T tem um nó especifico r, chamado de raiz de T, que não tem pai. • Cada nó v de T diferente de r tem um nó paiu. • Para todo nó v de T, a raiz r é um ascendente de v. • Uma definição recursiva: • um ascendente de um nó é tanto um nó ele mesmo ou um ascendente de um pai de nó. Ou seja: um nó v é um descendente de um nó u se u é um ascendente de v. • Exemplo 1: A relação de herança entre classes de um programa Java. • Se um nó u é pai de um nó v, então é dito que v é filho de u. • Dois nós que são filhos do mesmo pai são irmãos.

6. Terminologia e Propriedades Básicas Exemplo2: A árvore de directórios da maioria dos sistemas operativos: • Um nó é externo se ele não tem filhos. Um nó externo também é chamado de folha. • Um nó é interno se tem um ou mais filhos. • A sub-árvore de T cuja raiz é um nó v é uma árvore que consiste de todos os nós descendentes de v em T (incluindo v).

7. Terminologia e Propriedades Básicas • Uma árvore é ordenada, se existe uma ordem linear definida para os filhos de cada nó, de tal maneira que se possa identificar um nó como sendo o primeiro, o segundo, o terceiro e assim por diante. • Tal ordenação é determinada pelo uso que se deseja dar à árvore. • A ordenação da árvore é usualmente indicada na sua representação gráfica dispondo os irmãos da esquerda para a direita, correspondendo à relação linear. • Árvores ordenadas tipicamente indicam a relação linear existente entre irmãos, listando-os na sequência ou enumeração na ordem correcta.

8. Terminologia e Propriedades Básicas Exemplo3: Um documento estruturado como um livro é hierarquicamente organizado como uma árvore:

9. Métodos de Árvore • O TAD árvore armazena os elementos em posições as quais, tal como posições numa sequência, são definidas relativas às posições vizinhas: • Nas Árvores a noção de posição está relacionada com as relações pai-filho, definidas numa árvore válida. • Numa árvore também existe noção de posição (TAD Position), que suporta o método: • elemento(): retorna o objecto nesta posição. • Entrada: Nenhuma; Saída: Objecto.

10. Métodos de Árvore • Métodos de acesso: • root(): Retorna a raiz de T; se T está vazia, um erro ocorre. • Entrada: Nenhuma; Saída: Posição. • parent(v): Retorna o pai do nó v; um erro ocorre, se v = raiz(). • Entrada: Posição; Saída: Posição. • children(v): Retorna um iterador para os filhos do nó v. • Entrada: Posição; Saída: Enumeração de posições.

11. Métodos de Árvore • Métodos de pesquisa: • isInternal(v): Testa se a posição v é um nó interno. • Entrada: Posição; Saída: Booleano. • isExternal(v): Testa se a posição v é um nó externo. • Entrada: Posição; Saída: Booleano. • isRoot(v): Testa se a posição v é o nó raiz. • Entrada: Posição; Saída: Booleano.

12. Métodos de Árvore • Métodos genéricos: • size(): Retorna o número de nós em T. • Entrada: Nenhuma; Saída: Inteiro. • elements(): Retorna um iterador com todos os elementos armazenados em nós de T. • Entrada: Nenhuma; Saída: Iterador de objectos. • positions():Retorna um iterador com todas as posições (nós) de T. • Entrada: Nenhuma; Saída: Iterador de posições. • swapElements(v, w): Troca os elementos armazenados nos nós v e w de T. • Entrada: Duas posições; Saída: Nenhuma. • replaceElement(v, e):Substitui o elemento armazenado no nó v com e, retornando o elemento anteriormente armazenado em v. • Entrada: Uma posição e um objecto; Saída: Objecto.

13. Interface Proposta de um ADT Árvore

14. InterfaceInspectablePositionalContainer public interface InspectablePositionalContainer extends InspectableContainer { // accessor methods /** return the positions in the container */ public PositionIterator positions(); }

15. InterfacePositionalContainer public interface PositionalContainer extends InspectablePositionalContainer { // update methods /** swap the elements at two nodes */ public void swapElements(Position v, Position w); /** replace with and return the element at a node */ public Object replaceElement(Position v, Object e); }

16. InterfaceInspectableTree public interface InspectableTree extends InspectablePositionalContainer { // accessor methods /** return the root of the tree */ public Position root(); /** return the parent of a node */ public Position parent(Position v); /** return the children of a node */ public PositionIterator children(Position v); // query methods /** test whether a node is internal */ public boolean isInternal(Position v); /** test whether a node is external */ public boolean isExternal(Position v); /** test whether a node is the root of the tree */ public boolean isRoot(Position v); }

17. Interface Tree public interface Tree extends InspectableTree, PositionalContainer { }

18. Profundidade da Árvore • A profundidade de um no v de uma árvore T é o número de ascendentes de v, excluindo o próprio v. • A profundidade da raiz é 0. • A profundidade de um no pode também ser definida recursivamente como: • Se v é a raiz, então a profundidade é 0. • Caso contrario, a profundidade de v é um mais a profundidade do pai de v. • O fragmento de código recursivo: public int depth (InspectableTree T, PostionalContainer v) { // calculo recursiva da profundidade do no v if(T.isRoot(v)) { return 0; } return 1 + depth(T, T.parent(v)); }

19. Altura da Árvore • A altura de um no v numa árvore T é também definida recursivamente da seguinte maneira: • Se v é um no externo, então a altura de v é 0. • Caso contrário, a altura de v é um mais a altura máxima dos filhos de v. • A altura total de uma árvore T é definida como a altura da raiz de T. • Outra maneira de ver a altura de uma árvore T é a profundidade máxima de um no de T, que é encontrada em um ou mais nos externos. public static int height (InspectableTree T) { int h = 0; PositionIterator positer = T.positions(); while (positer.hasNext()) { Position v = positer.nextPosition(); if (T.isExternal(v)) h = Math.max(h, depth(T, v)); } return h; }

20. Largura da Árvore A largura de uma árvore T é definida através do conceito de grau. • O grau de um nó v É dado pelo número de subárvores a ele ligadas. • Grau de uma árvore T É o máximo grau entre todos os nós da árvore.

21. Tipos de deslocamento numa árvore • O deslocamento numa árvore é uma forma sistemática de aceder ou "visitar" todos os seus nos. • Existem dois tipos principais de deslocamento: • Pré-ordem (preorder): cada nó é processado antes de qualquer nó das suas subárvores. • Pós-ordem (postorder): cada nó é processado depois de todos os nós das suas subárvores.

22. Deslocamento pré-ordem • Em um deslocamento pré-ordem (preorder) de uma árvore T, a raiz é visitada primeiro e então as sub-árvores, cujas raízes são seus filhos, são visitados recursivamente. • A acção específica associada à "visita" de um no (processamento do no) depende de cada aplicação. • Inicialmente a chamada desta rotina é preOrdem(T, T.raiz()). Algoritmo preOrdem(T, v) realize a acção de "visita" para o no v para cada filho w de vfaça caminhe recursivamente a sub-árvore de raiz w pela chamada de preOrdem(T, w)

23. Deslocamento pré-ordem

24. Deslocamento pos-ordem • O algoritmo pós-ordem (postorder) pode ser visto como o oposto do algoritmo de deslocamento pré-ordem, porque ele primeiro caminha recursivamente as sub-árvores cujas raízes são os filhos da raiz e só em seguida visita a raiz. Algoritmo posOrdem(T, v) para cada filho w de vfaça caminhe recursivamente a sub-árvore de raiz w pela chamada de posOrdem(T, w) realize a ação de "visita" para o nó v

25. Deslocamento pos-ordem

26. Formas de representação - Lista Ligada • Cada nó da árvore de grau arbitrário pode ser especificado pelos seguintes componentes: • Objectelemento; • Arv_No filhos; /* lista de descendentes / filhos */ • Arv_No irmaos; /* lista de irmãos */ A inserção será feita na lista ligada contendo os seus irmãos. Isto implica o conhecimento prévio do ascendente.