So she went on, wondering more and more at every step, as everything turned into a tree the moment she came up to it.

Transcrição

1 Capítulo 14 Árvores So she went on, wondering more and more at every step, as everything turned into a tree the moment she came up to it. Lewis Carroll, Through the Looking Glass A árvore é um tipo estruturado de informação que é muito utilizado em programação. No diaadia, utilizamos árvores para representar, por exemplo, a estrutura hierárquica de organizações e árvores genealógicas. Em informática, as árvores podem ser utilizadas para representar, entre muitas outras, estruturas de expressões (como foi feito nas figuras 1.4 a 1.7) e as funções invocadas durante a execução de um processo (como foi feito nas figuras 10.5 e 10.9). Uma árvore 1 é um tipo que apresenta uma relação hierárquica entre os seus constituintes. A terminologia utilizada para designar os constituintes de uma árvore mistura termos provenientes das árvores que aparecem na natureza e termos provenientes de árvores genealógicas. Uma árvore pode ser vazia ou ser constituída por um elemento, a raiz da árvore, a qual domina, hierarquicamente, outras árvores. Uma árvore que apenas domina árvores vazias chamase uma folha. As árvores dominadas chamamse filhas da árvore dominadora, e esta árvore chamase mãe das árvores dominadas. A ligação entre uma árvore e a árvore dominada é chamada um ramo da árvore. Em programação, as árvores são normalmente escritas com a raiz no topo e com 1 Em inglês tree. 397

2 398 CAPÍTULO 14. ÁRVORES A B C D E F G H I J Figura 14.1: Exemplo de uma árvore. as folhas na base. Na Figura 14.1, mostramos uma árvore cuja raiz é rotulada com A. Esta árvore domina três árvores: (1) uma árvore cuja raiz é rotulada com B e apenas domina árvores vazias; (2) uma árvore cuja raiz é rotulada com C; e (3) uma árvore cuja raiz é rotulada com D. A é a mãe de B, C e D; G é fi l h a de D; as folhas da árvore são rotuladas com B, E, F, H, I e J. Existe um caso particular de árvores, as árvores binárias, em que cada raiz domina exactamente duas árvores binárias. Uma árvore binária ou é vazia ou é constituída por uma raiz que domina duas árvores binárias, a árvore esquerda e a árvore direita. A árvore apresentada na Figura 14.1 não é binária, porque algumas das suas árvores (nomeadamente, as árvores cujas raízes são rotuladas com A e com G) dominam mais do que duas árvores. Na Figura 14.2, apresentamos uma árvore binária. É importante notar que a árvore cuja raiz é C domina à sua esquerda a árvore vazia e à sua direita a árvore cuja raiz é F. Nesta secção, apenas consideramos árvores binárias. Isto não representa uma limitação séria, porque qualquer árvore pode ser transformada numa árvore binária 2. Daqui em diante, utilizaremos a palavra árvore, como sinónimo de árvore binária. 2 Ver [Knuth, 1973a], Secção

3 14.1. OPERAÇÕES BÁSICAS PARA ÁRVORES 399 A B C D E F G H Figura 14.2: Exemplo de uma árvore binária Operações básicas para árvores Apenas iremos definir árvores como entidades imutáveis. O primeiro passo para a criação do tipo árvore consiste em definir as suas operações básicas: 1. Construtores: Os construtores para o tipo árvore incluem uma operação que gera árvores a partir do nada, à qual chamaremos nova arv. O outro construtor é uma operação que recebe como argumentos uma raiz e duas árvores, e que cria uma árvore com essa raiz cujas árvores esquerda e direita são as árvores recebidas. Esta operação será chamada cria arv. 2. Selectores: Deveremos ter um selector para escolher a raiz da árvore e selectores para a árvore esquerda e para a árvore direita. Estes selectores são chamados, respectivamente, raiz, arv esq e arv dir. 3. Reconhecedores: A operação árvore tem como argumento um elemento de qualquer tipo e decide se este corresponde ou não a uma árvore. A operação arv vazia tem como argumento uma árvore e decide se esta corresponde ou não à árvore vazia (a árvore gerada por nova arv).

4 400 CAPÍTULO 14. ÁRVORES 4. Testes: A operação arv iguais tem como argumentos duas árvores e decide se estas são iguais. Em resumo, o tipo árvore tem as seguintes operações básicas, as quais se referem ao tipo elemento que corresponde ao tipo dos elementos da raiz: 1. Construtores: nova arv : {} 7! árvore nova arv() tem como valor uma árvore vazia. cria arv : elemento árvore árvore 7! árvore cria arv(raiz, a esq,a dir ) tem como valor a árvore com raiz raiz, com árvore esquerda a esq e com árvore direita a dir. 2. Selectores: raiz :árvore 7! elemento raiz(árv) recebe uma árvore, árv, e tem como valor a sua raiz. Se a árvore for vazia, o valor desta operação é indefinido. arv esq :árvore 7! árvore arv esq(árv) recebe uma árvore, árv, e tem como valor a sua árvore esquerda. Se a árvore for vazia, o valor desta operação é indefinido. arv dir :árvore 7! árvore arv dir(árv) recebe uma árvore, árv, e tem como valor a sua árvore direita. Se a árvore for vazia, o valor desta operação é indefinido. 3. Reconhecedores: arv : universal 7! lógico arv(arg) tem o valor verdadeiro se arg é uma árvore e tem o valor falso, em caso contrário. arv vazia :árvore 7! lógico arv vazia(árv) tem o valor verdadeiro se árv é uma árvore vazia e tem o valor falso, em caso contrário.

5 14.2. AXIOMATIZAÇÃO Testes: arv iguais :árvore árvore 7! lógico arv iguais(árv 1, árv 2 ) tem o valor verdadeiro se árv 1 eárv 2 são árvores iguais e tem o valor falso, em caso contrário. De modo a utilizarmos o tipo árvore temos ainda de definir os transformadores de entrada e de saída, os quais transformam entre a representação que utilizamos para árvores, a representação externa, e a representação utilizada no nosso programa 3. Seria interessante utilizar como representação externa para árvores uma representação gráfica como a que apresentamos nas figuras 14.1 e Para isso, poderemos utilizar as funções gráficas apresentadas na Secção Por uma questão de simplicidade, optamos por uma representação externa para árvores, tal como a que apresentamos na Figura 14.3, a qual corresponde à árvore da Figura A nossa representação externa utiliza as seguintes convenções: (1) a árvore vazia é representada por ; (2) a árvore esquerda e a árvore direita de uma árvore são escritas em linhas diferentes (começando à mesma distância da margem esquerda), e dois espaços mais para a direita do que a sua raiz, que aparece na linha acima. A operação escreve arv recebe uma árvore e mostraa de acordo com esta convenção Axiomatização Entre as operações básicas devemos impor as seguintes condições (axiomatização), em que a, a 1 e a 2 são árvores e r é um elemento da raiz de uma árvore 4 : arv(nova arv()) = verdadeiro arv(cria arv(r, a 1,a 2 )) = verdadeiro arv vazia(nova arv()) = verdadeiro arv vazia(cria arv(r, a 1,a 2 )) = falso raiz(cria arv(r, a 1,a 2 )) = r 3 Novamente, não iremos definir o transformador de entrada. 4 Por uma questão de simplicidade, nas duas últimas equações omitimos a verificação de árvore não vazia.

6 402 CAPÍTULO 14. ÁRVORES A B D E G H C F Figura 14.3: Representação externa da árvore da Figura arv esq(cria arv(r, a 1,a 2 )) = a 1 arv dir(cria arv(r, a 1,a 2 )) = a 2 cria arv(raiz(a),arv esq(a),arv dir(a)) = a arv iguais(a, cria arv(raiz(a), arv esq(a), arv dir(a))) = verdadeiro 14.3 Representação de árvores A escolha de uma representação interna para árvores vai ser influenciada pelo tipo de programa que queremos utilizar para o tipo árvore. Podemos pensar em realizar o tipo árvore usando funções ou podemos realizar o tipo árvore como objectos Representação para o uso recorrendo a funções Criar o tipo árvore recorrendo a funções, precisamos que as árvores estejam contidas numa única estrutura de informação, a qual será passada às várias funções que manipulam árvores. Uma das possíveis representações internas para

7 14.3. REPRESENTAÇÃO DE ÁRVORES 403 <[Árvore vazia] = [] =[<[R], <[A e ], <[A d ]] A e A d Figura 14.4: Representação de árvores utilizando listas. árvores recorre a listas e poderá ser definida do seguinte modo (Figura 14.4): 1. Uma árvore vazia é representada lista vazia []. 2. Uma árvore não vazia é representada por uma lista cujo primeiro elemento contém a raiz da árvore, cujo segundo elemento contém a representação da árvore esquerda e cujo terceiro elemento contém a representação da árvore direita. Por exemplo, a árvore da Figura 14.2, será representada pela lista [A, [B, [D, [], []], [E, [G, [], []], [H, [], []]]], [C, [], [F, [], []]]], ou, de uma forma mais intuitiva, baseandonos no princípio que utilizámos para a representação externa: [A, [B, [D, [], []], [E, [G, [], []], [H, [], []]]], [C, [], [F, [], []]]]

8 404 CAPÍTULO 14. ÁRVORES <[Árvore vazia] = self.e :? self.r : None self.d :? = A e A d self.r : <[R] self.e : <[A e ] self.d : <[A d ] Figura 14.5: Representação de árvores recorrendo a objectos Representação para o uso recorrendo a objectos Sabemos que um objecto é uma entidade com estado interno. Representado as árvores como objectos, o estado interno desses objectos deverá conter os diferentes constituintes de uma árvore. Neste caso, podemos utilizar três componentes distintos para representar os três constituintes de uma árvore, a raiz, a árvore esquerda e a árvore direita. Embora estas três entidades sejam distintas, elas existem dentro das instâncias da classe árvore. Assim, uma árvore será representada por três variáveis, self.r, self.e e self.d, contendo, respectivamente, a raiz, a árvore esquerda e a árvore direita. Para representar uma árvore vazia, vamos recorrer a um tipo de informação elementar existente em Python, o tipo None. OtipoNone tem apenas uma constante, None, a qual representa nada. Já tínhamos apresentado este tipo, embora não explicitamente, quando na página 58 dissemos que a função print não devolve qualquer valor. A representação externa desta constante não é mostrada pelo Python quando uma expressão tem o valor None como o mostra a seguinte interacção: >>> None >>> Assim, a representação que escolhemos para árvores é apresentada na Figura 14.5 (recordese que? representa indefinido).

9 14.4. REALIZAÇÃO DAS OPERAÇÕES BÁSICAS Realização das operações básicas Apresentamos a realização das operações básicas para as duas alternativas apresentadas na Secção Árvores recorrendo a funções def nova_arv(): return [] def cria_arv(r, a_e, a_d): if arvore(a_e) and arvore(a_d): return [r, a_e, a_d] raise ValueError ( cria_arv: o segundo e terceiro \ argumentos devem ser árvores ) def raiz(a): if a == []: raise ValueError ( raiz: a árvore é vazia ) return a[0] def arv_esq(a): if a == []: raise ValueError ( arv_esq: a árvore é vazia ) return a[1] def arv_dir(a): if a == []: raise ValueError ( arv_dir: a árvore é vazia ) return a[2]

10 406 CAPÍTULO 14. ÁRVORES def arvore(x): if isinstance(x, list): if x == []: return True elif len(x) == 3 and \ arvore(x[1]) and \ arvore(x[2]): return True return False return False def arv_vazia(a): return a == [] def arv_iguais (a1, a2): if arv_vazia(a1): return arv_vazia(a2) elif arv_vazia(a2): return False elif raiz(a1) == raiz(a2): return arv_iguais(arv_esq(a1), arv_esq(a2)) and \ arv_iguais(arv_dir(a1), arv_esq(a2)) return False def escreve_arv(a): def escreve_aux(a, indent): if arv_vazia(a): print( * indent, ) print( * indent, raiz(a)) escreve_aux(arv_esq(a), indent + 2)

11 14.4. REALIZAÇÃO DAS OPERAÇÕES BÁSICAS 407 escreve_aux(arv_dir(a), indent + 2) escreve_aux(a, 0) Notese que poderíamos term pensado em escrever a função arv iguais como: def arv_iguais (a1, a2): return a1 == a2 Embora esta função produza resultados correctos em Python para a representação escolhida, esta abordagem simplista poderá não funcionar correctamente para outras representações A classe árvore Recordemos que definimos dois construtores para árvores, a operação nova arv o que gera árvores a partir do nada e a operação cria arv que recebe como argumentos uma raiz e duas árvores, e que cria uma árvore com essa raiz cujas árvores esquerda e direita são as árvores recebidas. Existem pois dois modos distintos de construir árvores, modos esses que devem ser contemplados pelo método init : se não lhe forem fornecidos argumentos, então init deve construir uma árvore vazia; se lhe forem fornecidos uma raiz e duas árvores, então init constrói uma árvore não vazia. Precisamos pois de definir uma função, init, que recebe um número variável de argumentos. Ométodo init para a classe arvore deve permitir a utilização de zero ou três argumentos. class arvore: def init (self, *args): if args == (): self.r = None if len(args) == 3: if isinstance(args[1], arvore) and \ isinstance(args[2], arvore):

12 408 CAPÍTULO 14. ÁRVORES self.r = args[0] self.e = args[1] self.d = args[2] raise ValueError ( arvore: o segundo e \ terceiro argumentos devem ser arvores ) raise ValueError ( arvore: aceita zero ou \ tr^es argumentos ) def raiz(self): if self.r == None: raise ValueError ( raiz: a arvore é vazia ) return self.r def arv_esq(self): if self.r == None: raise ValueError ( arv_esq: a arvore é vazia ) return self.e def arv_dir(self): if self.r == None: raise ValueError ( arv_dir: a arvore é vazia ) return self.d def arv_vazia(self): return self.r == None

13 14.5. ORDENAÇÃO POR ÁRVORE 409 def repr (self): def repr aux(a, indent): if a.r == None: return * indent + + \n return * indent + \ [ + str(a.r) + \n +\ repr aux(a.e, indent + 2) + \ repr aux(a.d, indent + 2) + \ * (indent + 2) + ] + \n return repr aux(self, 0) 14.5 Ordenação por árvore Nesta secção, apresentamos uma aplicação que utiliza árvores, a ordenação por árvore. A ordenação por árvore é um algoritmo de ordenação muito eficiente, executado em dois passos sequenciais: primeiro coloca os elementos a serem ordenados numa árvore binária (chamada árvore binária de procura), depois percorre esta árvore seguindo um método determinado, visitando as raízes das árvores que a constituem. Isto é feito de modo a que a primeira raiz visitada contenha o menor elemento, a segunda raiz visitada, o elemento que é imediatamente maior, e assim sucessivamente. A árvore binária é construída do seguinte modo. Começando com uma árvore vazia, inserimos nesta árvore os elementos a serem ordenados, um de cada vez. 1. Um elemento é inserido numa árvore vazia através da criação de uma árvore cuja raiz contém o elemento a inserir e em que as árvores esquerda e direita são vazias. 2. Um elemento é inserido numa árvore não vazia comparando o elemento com a raiz da árvore. Se o elemento a ser inserido for maior do que o elemento que se encontra na raiz da árvore, o elemento é inserido, utilizando o mesmo método, na árvore direita da árvore inicial, caso contrário, é inserido, pelo mesmo método, na árvore esquerda.

14 410 CAPÍTULO 14. ÁRVORES 5 14 Figura 14.6: Árvore depois da inserção de 5 e de Figura 14.7: Árvore depois da inserção de 8. Como exemplo desta função, suponhamos que desejávamos criar uma árvore binária de procura com os elementos 5, 14, 8, 2 e 20. Em primeiro lugar, criamos uma árvore vazia, onde inserimos o elemento 5, criando uma árvore cuja raiz contém 5 e em que as árvores esquerda e direita são vazias. Seguidamente, inserimos o elemento 14 nesta árvore. Uma vez que 14 > 5 (5 é a raiz da árvore), 14 é inserido na árvore da direita, originando a árvore apresentada na Figura O elemento seguinte a ser inserido é 8. Uma vez que 8 > 5, este elemento será introduzido na árvore da direita. Para inserir este elemento na árvore da direita, este é comparado com a raiz, e, uma vez que 8 < 14, este é inserido na árvore da esquerda, dando origem à árvore apresentada na Figura Em seguida, inserese o número 2. Uma vez que 2 < 5, este elemento será inserido na árvore da esquerda, dando origem à árvore apresentada na Figura Finalmente, inserimos o elemento 20, dando origem à árvore apresentada na Figura Uma vez construída a árvore, teremos de a percorrer, visitando as raízes das suas árvores. As raízes devem ser visitadas por ordem crescente dos elementos existentes na árvore.

15 14.5. ORDENAÇÃO POR ÁRVORE Figura 14.8: Árvore depois da inserção de Figura 14.9: Árvore depois da inserção de 20. O algoritmo para percorrer a árvore é o seguinte: 1. Percorrer uma árvore vazia não causa nenhuma acção. 2. Para percorrer uma árvore não vazia, primeiro percorremos a sua árvore da esquerda, depois visitamos a raiz, depois percorremos a sua árvore da direita. Por exemplo, considerando a árvore da Figura 14.9, uma vez que esta árvore não é vazia, teremos primeiro de percorrer a sua árvore da esquerda, depois visitar a raiz e depois percorrer a árvore da direita. Para percorrer a árvore da esquerda (cuja raiz contém 2), teremos de percorrer a árvore da esquerda (que é vazia), visitar a raiz, que contém o valor 2, e depois percorrer a árvore da direita, que também é vazia. Acabamos assim de percorrer a árvore cuja raiz contém 2, visitamos agora a raiz da árvore original, que contém 5, e percorremos a árvore da direita. O processo repetese para a árvore da direita. Deixamos como

16 412 CAPÍTULO 14. ÁRVORES exercício a verificação de que os elementos são visitados por ordem crescente do seu valor. A função ordena arvore recebe uma lista contendo valores a ordenar e devolve a lista correspondente à ordenação dos elementos recebidos. Esta função utiliza a definição de árvores como objectos. def ordena_arvore(lst): return percorre(lista_para_arvore(lst)) def lista_para_arvore(lst): def insere_arv(lst, arv): def insere_elemento(el, arv): if arv.arv_vazia(): return arvore(el, arvore(), arvore()) elif el > arv.raiz(): return arvore(arv.raiz(), \ arv.arv_esq(), \ insere_elemento(el, arv.arv_dir())) return arvore(arv.raiz(), \ insere_elemento(el, arv.arv_esq()), \ arv.arv_dir()) if lst == []: return arv return insere_arv(lst[1:], \ insere_elemento(lst[0], arv)) return insere_arv(lst, arvore())

17 14.6. NOTAS FINAIS 413 def percorre(arv): if arv.arv_vazia(): return [] return percorre(arv.arv_esq()) + \ [arv.raiz()] + \ percorre(arv.arv_dir()) Com a qual podemos gerar a interacção: >>> ordena_arvore([5, 14, 8, 2, 20]) [2, 5, 8, 14, 20] 14.6 Notas finais Apresentámos o tipo árvore que é muito utilizado em programação. Informação adicional sobre árvores e algoritmos que as manipulam podem ser consultados em [Knuth, 1973b] e em [Cormen et al., 2009] Exercícios 1. Escreva uma função chamada arv soma elementos que recebe como argumento uma árvore cujos nós são números e devolve a soma dos números representados na árvore. 2. Escreva uma função chamada arv espelha que recebe uma árvore e devolve uma nova árvore idêntica à recebida, mas em que em cada nível da árvore se trocou a árvore esquerda com a direita, mantendose a raiz. 3. Escreva uma função chamada arv transforma que recebe como argumentos uma árvore e uma função de um argumento aplicável aos elementos da árvore e devolve uma nova árvore cujos elementos correspondem à aplicação da função aos elementos da árvore na posição correspondente. 4. Defina a representação externa para árvores utilizando uma interface gráfica.