EAD ARVORE BINÁRIA - ARMAZENAMENTO NÃO SEQUENCIAL COM VETORES

Transcrição

1 EAD ARVORE BINÁRIA - ARMAZENAMENTO NÃO SEQUENCIAL COM VETORES Estrutura de dados: - Arvore é um vetor em que cada componente (nodo) é composto por 3 campos: - Elemento (informação a tratar), que pode ser um tipo de dados - não estruturado básico (inteiro, real, caracter,...), ou - estruturado (vetor, matriz, registo,...); se o tipo de dados é um registo, então é composto por um ou mais subcampos (dependendo do volume de informação a tratar) em que um deles pode funcionar como Chave (base para ordenar e pesquisar na lista); - Esquerda (índice do nodo da raiz da subárvore esquerda), que é um número inteiro; - Direita (índice do nodo da raiz da subárvore direita), que é um número inteiro; - Raiz (índice do nodo que contém o elemento da raiz da árvore). - Representação de um nodo da árvore: Nodo Elemento Esquerda Direita Informação Subárvore Subárvore 1

2 Exemplo: Árvore com 10 nodos, em que o elemento de cada nodo é um inteiro. Representação gráfica: Estrutura de dados: Arvore(k) = struct { Elemento, Esquerda, Direita }, k = 1,..., 10 Arvore é um tipo de dados estruturado, mais especificamente um registo (estrutura); Elemento é um tipo de dados não estruturado básico (inteiro). Raiz = 1 2

3 Arvore Elemento Esquerda Direita Implementação em MatLab: Arvore(1).Elemento = 86; Arvore(1).Esquerda = 2; Arvore(1).Direita = 3; Arvore(2).Elemento = 28; Arvore(2).Esquerda = 4; Arvore(2).Direita = 6; Arvore(3).Elemento = 59; Arvore(3).Esquerda = 5; Arvore(3).Direita = 7; Arvore(4).Elemento = 81; Arvore(4).Esquerda = 0; Arvore(4).Direita = 0; Arvore(5).Elemento = 49; Arvore(5).Esquerda = 0; Arvore(5).Direita = 0; Arvore(6).Elemento = 47; Arvore(6).Esquerda = 8; Arvore(6).Direita = 10; Arvore(7).Elemento = 71; Arvore(7).Esquerda = 0; Arvore(7).Direita = 9; Arvore(8).Elemento = 76; Arvore(8).Esquerda = 0; Arvore(8).Direita = 0; Arvore(9).Elemento = 40; Arvore(9).Esquerda = 0; Arvore(9).Direita = 0; Arvore(10).Elemento = 11; Arvore(10).Esquerda = 0; Arvore(10).Direita = 0; 3

4 Operações básicas sobre uma árvore binária: - Criar um nodo de uma árvore binária - Criar uma árvore binária (com um elemento) - Verificar se uma árvore binária está vazia - Libertar/destruir um nodo de uma árvore binária - Determinar o número de elementos/nodos de uma árvore binária - Determinar a altura (número de níveis) de uma árvore binária - Listar os elementos de uma árvore binária (pré-ordem; em-ordem; pós-ordem) - Pesquisar um elemento numa árvore binária - Consultar um elemento numa árvore binária - Inserir um elemento numa árvore binária - Remover um elemento de uma árvore binária Outras operações sobre uma árvore binária: - Determinar o maior elemento de uma árvore binária - Verificar se duas árvores binárias são iguais - Alterar/atualizar os dados de um Elemento de uma árvore binária - Trocar dois elementos de uma árvore binária 4

5 Criar um nodo de uma árvore binária a partir de um elemento Representação gráfica: Nodo Elemento Estrutura de dados (representação): Parâmetros: Nodo Elemento Elemento Esquerda 0 Direita 0 Entrada: informação referente a um elemento (Elem) Saída: um nodo isolado composto pelo elemento dado e sem ligações a subárvores (Nodo) Função implementada em MatLab (iterativa): function [Nodo] = CriarNodoArvore (Elem) Nodo.Elemento = Elem; Nodo.Esquerda = 0; Nodo.Direita = 0; 5

6 Criar uma árvore binária (com um elemento) Representação gráfica: Arvore Elem Estrutura de dados (representação): Parâmetros: Arvore Elemento Elem Esquerda 0 Direita 0 Entrada: informação referente a um elemento (Elem) Saída: árvore com um só nodo (Arvore) e raiz da árvore (Raiz) Função implementada em MatLab (iterativa): function [Arvore, Raiz] = CriarArvoreBinaria (Elem) nodo = CriarNodoArvore(Elem); Arvore(1) = nodo; Raiz = 1; 6

7 Verificar se uma árvore binária está vazia Notas: - uma árvore está vazia se o nodo associado à raiz é nulo Parâmetros: Entrada: raiz da árvore (Raiz) Saída: 1, se a árvore está vazia, ou 0, se a árvore não está vazia (vazia) Função implementada em MatLab (iterativa): function [vazia] = ArvoreBinariaVazia (Raiz) if Raiz == 0 vazia = 1; else vazia = 0; 7

8 Libertar um nodo de uma árvore binária Notas: - depois de um elemento ser eliminado da árvore, é necessário remover o seu nodo do vetor (isto é, libertar o nodo da árvore); - o elemento depois de eliminado da árvore já não entra no cálculo do número de nodos da árvore, apesar do seu nodo ainda fazer parte do vetor, ou seja - número de nodos da árvore = tamanho vetor - 1; - o nodo a libertar tem nos seus campos Esquerda e Direita o valor -1; - a libertação do nodo consiste em redefinir o vetor da árvore, de tal forma que todos os nodos da árvore fiquem nas primeiras posições do vetor, ficando no último índice um nodo com um elemento que deixa de fazer parte da árvore (tamanho árvore < tamanho vetor); - este processo consiste em 3 passos: 1º) "encostar" todos os nodos da árvore à esquerda no vetor (primeiras posições), 2º) atualizar os índices dos sucessores dos nodos da árvore (os que forem necessários), 3º) atualizar a raiz da árvore (se for necessário). 8

9 Parâmetros: Entrada: árvore (Arvore), raiz da árvore (Raiz) e nodo a libertar (indnodo) Saída: árvore (Arvore) e raiz da árvore (Raiz) atualizadas Algoritmo (iterativo): Determinar o número de nodos da árvore (tam) Se a árvore está vazia (tam = 0) Então Sair (o nodo a libertar está no fim do vetor da árvore índice 1) Senão Determinar o índice do nodo a libertar (indnodo) Se o nodo a libertar está na última posição do vetor ou não existe (indnodo > tam) Então Eliminar o nodo do vetor da posição indnodo e atualizar a sua dimensão Sair (o nodo a libertar está no fim do vetor da árvore) Senão Eliminar o nodo do vetor da posição indnodo e atualizar a sua dimensão Atualizar o campo Esquerda dos nodos com valores maiores do que indnodo Atualizar o campo Direita dos nodos com valores maiores do que indnodo Atualizar a raiz da árvore (se for um valor superior a indnodo) 9

10 Função implementada em MatLab (iterativa): function [Arvore, Raiz] = LibertarNodoArvore (Arvore, Raiz, indnodo) tam = NumeroNodosArvore(Arvore, Raiz); if tam == 0 % verificar se o índice do nodo a libertar é o último índice do vetor if indnodo > tam % não existe nodo a libertar ou está no fim do vetor Arvore(indNodo) = []; % a árvore tem um elemento a menos, mas o vetor da árvore mantém o nodo; % assim, este nodo deve ser libertado do vetor (isto é, eliminado) % primeiro: eliminar o nodo da posição indnodo e atualizar a sua dimensão Arvore(indNodo) = []; 10

11 % segundo: atualizar os campos Esquerda e Direita dos nodos com valores superiores a indnodo for i = 1:tam if Arvore(i).Esquerda > indnodo Arvore(i). Esquerda = Arvore(i). Esquerda - 1; if Arvore(i).Direita > indnodo Arvore(i). Direita = Arvore(i). Direita - 1; % terceiro: atualizar a raiz da árvore, Raiz, se for um índice superior a indnodo if Raiz >= indnodo Raiz = Raiz - 1; 11

12 Determinar o número de nodos de uma árvore binária Parâmetros: Entrada: árvore (Arvore) e raiz da árvore (Raiz) Saída: número de nodos da árvore (numnodos) Algoritmo (recursivo): Se a árvore está vazia Então { Caso terminal/paragem - árvore vazia } Número nodos da árvore 0 Senão { Caso geral - árvore não vazia } Número nodos da árvore Número nodos da subárvore esquerda + Número nodos da subárvore direita + 1 (raiz) 12

13 Função implementada em MatLab (recursiva): function [numnodos] = NumeroNodosArvore (Arvore, Raiz) if Raiz == 0 % Caso terminal/paragem - árvore vazia numnodos = 0; % Caso geral - árvore não vazia % número de nodos da subárvore esquerda numnodosesq = NumeroNodosArvore(Arvore, Arvore(Raiz).Esquerda); % número de nodos da subárvore direita numnodosdir = NumeroNodosArvore(Arvore, Arvore(Raiz).Direita); % número de nodos da árvore numnodos = numnodosesq + numnodosdir + 1; 13

14 Determinar a altura de uma árvore binária Parâmetros: Entrada: árvore (Arvore) e raiz da árvore (Raiz) Saída: altura da árvore (altura) Algoritmo (recursivo): Se a árvore está vazia Então { Caso terminal/paragem - árvore vazia } Altura da árvore 0 Senão { Caso geral - árvore não vazia } Altura da árvore maior { altura da subárvore esquerda, altura da subárvore direita } + 1 (raiz) 14

15 Função implementada em MatLab (recursiva): function [altura] = AlturaArvore (Arvore, Raiz) if Raiz == 0 % Caso terminal/paragem - árvore vazia altura = 0; % Caso geral - árvore não vazia % altura da subárvore esquerda alturaesq = AlturaArvore(Arvore, Arvore(Raiz).Esquerda); % altura da subárvore direita alturadir = AlturaArvore(Arvore, Arvore(Raiz).Direita); % altura da árvore = maior { altura da subárvore esquerda, altura da subárvore direita } + 1 (raiz) if alturaesq > alturadir altura = alturaesq + 1; else altura = alturadir + 1; 15

16 Listar os elementos de uma árvore binária Travessia em pré-ordem: raiz, subárvore esquerda e subárvore direita. Travessia em em-ordem: subárvore esquerda, raiz e subárvore direita. Travessia em pós-ordem: subárvore esquerda, subárvore direita e raiz. Pré-ordem: Em-ordem: Pós-ordem:

17 Parâmetros: Entrada: árvore (Arvore) e raiz da árvore (Raiz) Saída: mostra os elementos da árvore, segundo um tipo de travessia Funções (3) implementadas em MatLab (recursivas): Nota: MostrarElemento é uma operação específica do problema % pré-ordem: raiz, subárvore esquerda e subárvore direita function [] = ListarPreOrdem (Arvore, Raiz) if Raiz == 0 % Caso paragem/terminal - árvore vazia else % Caso geral - árvore não vazia MostrarElemento(Arvore(Raiz).Elemento); ListarPreOrdem(Arvore, Arvore(Raiz).Esquerda); ListarPreOrdem(Arvore, Arvore(Raiz).Direita); 17

18 % em-ordem: subárvore esquerda, raiz e subárvore direita function [] = ListarEmOrdem (Arvore, Raiz) if Raiz == 0 % Caso paragem/terminal - árvore vazia else % Caso geral - árvore não vazia ListarEmOrdem(Arvore, Arvore(Raiz).Esquerda); MostrarElemento(Arvore(Raiz).Elemento); ListarEmOrdem(Arvore, Arvore(Raiz).Direita); % pós-ordem: subárvore esquerda, subárvore direita e raiz function [] = ListarPosOrdem (Arvore, Raiz) if Raiz == 0 % Caso paragem/terminal - árvore vazia else % Caso geral - árvore não vazia ListarPosOrdem(Arvore, Arvore(Raiz).Esquerda); ListarPosOrdem(Arvore, Arvore(Raiz).Direita); MostrarElemento(Arvore(Raiz).Elemento); 18

19 Pesquisar um elemento numa árvore binária Notas: - A informação contida no elemento a pesquisar basta incidir sobre o valor da sua Chave. - Estratégia (processo recursivo): - analisar dois casos terminais/paragem: a) se a árvore está vazia, então o elemento não existe; b) se o elemento da raiz é igual ao elemento a pesquisar, então existe na raiz; - analisar o caso geral: a) pesquisar o elemento na subárvore esquerda (direita); b) se não está na subárvore esquerda (direita), então pesquisar na subárvore direita (esquerda). Parâmetros: Entrada: elemento a pesquisar (Elem), árvore (Arvore) e raiz da árvore (Raiz) Saída: índice do elemento, se existe na árvore, ou 0, se não existe na árvore (indnodo) 19

20 Algoritmo (recursivo): { Caso de paragem/terminal - árvore vazia } Se a árvore está vazia então Atribuir a indnodo o valor 0 { Caso de paragem/terminal - elemento = elemento da raiz } Se o elemento que está na raiz é igual ao elemento a pesquisar então Atribuir a indnodo o valor da raiz { Caso geral - pesquisar na subárvore esquerda e depois na direita (se necessário) } Pesquisar o elemento na subárvore esquerda da raiz Se o elemento não está na subárvore esquerda então Pesquisar o elemento na subárvore direita da raiz 20

21 Função implementada em MatLab (recursiva): Nota: CompararElementos é uma operação específica do problema function [indnodo] = PesquisarElementoArvore (Elem, Arvore, Raiz) if Raiz == 0 % Caso terminal/paragem - Elem não existe na árvore indnodo = 0; if CompararElementos(Arvore(Raiz).Elemento, Elem) == 0 % Caso terminal/paragem - Elem existe na árvore na posição Raiz do vetor indnodo = Raiz; % Caso geral - pesquisar o elemento nas subárvores esquerda e direita (se não existir na esquerda) indnodo = PesquisarElementoArvore(Elem, Arvore, Arvore(Raiz).Esquerda); % se não está na subárvore esquerda, então pesquisar na subárvore direita if indnodo == 0 indnodo = PesquisarElementoArvore(Elem, Arvore, Arvore(Raiz).Direita); 21

22 Consultar um elemento de uma árvore binária Notas: - A informação contida no elemento a consultar basta incidir sobre o valor da sua Chave. - Estratégia: pesquisar o elemento na árvore e mostar toda a informação sobre ele (se existe) ou uma mensagem a indicar que não existe. Parâmetros: Entrada: elemento a pesquisar (Elem), árvore (Arvore) e raiz da árvore (Raiz) Saída: mostra os dados do elemento com a mesma Chave de Elem (se está na árvore) Função implementada em MatLab (iterativa): Nota: MostrarElemento é uma operação específica do problema function [] = ConsultarElementoArvore (Elem, Arvore, Raiz) % indnodo é índice do nodo com Elem (se não existe, indnodo = 0) indnodo = PesquisarElementoArvore(Elem, Arvore, Raiz); if indnodo == 0 disp('elemento nao pertence a lista!'); % Elem não pertence à lista else MostrarElemento(Arvore(indNodo).Elemento); % Elem pertence à lista 22

23 Inserir um elemento numa árvore binária Notas: - O elemento a inserir é sempre inserido como folha da árvore; - Processo deve começar pela pesquisa da posição de inserção do elemento na árvore; - Há necessidade da pesquisa obedecer a algum critério, para que exista uniformidade na distribuição dos nodos pela árvore (a árvore não deve ficar totalmente desequilibrada). - Alguns critérios possíveis são: 1º) inserir como folha na subárvore de menor tamanho, 2º) tendo o mesmo tamanho, inserir na subárvore com menos nodos. Parâmetros: Entrada: elemento a inserir (Elem), árvore (Arvore) e raiz da árvore (Raiz) Saída: árvore (Arvore) e raiz da árvore (Raiz) atualizadas 23

24 Algoritmo (iterativo): Criar um novo nodo com o elemento a inserir Se a árvore está vazia Então Inserir o novo nodo na primeira posição do vetor (início da lista) Senão Determinar a posição do novo elemento no vetor (último índice) Pesquisar (processo recursivo) a posição de inserção do novo elemento na árvore (o pai do novo nodo) Acrescentar o novo nodo ao vetor da árvore Ligar o novo nodo à árvore como filho do nodo associado à posição de inserção 24

25 Função implementada em MatLab (iterativa): function [Arvore, Raiz] = InserirElementoArvore (Elem, Arvore, Raiz) Nodo = CriarNodoArvore(Elem); if Raiz == 0 % árvore está vazia Arvore(1) = Nodo; Raiz = 1; indnodo = NumeroNodosArvore(Arvore, Raiz) + 1; painodo = DeterminarPaiNodo(Arvore, Raiz, 0); % 0 é o índice do nodo pai da raiz Arvore(indNodo) = Nodo; if Arvore(paiNodo).Esquerda == 0 Arvore(paiNodo).Esquerda = indnodo; else Arvore(paiNodo).Direita = indnodo; 25

26 function [painodo] = DeterminarPaiNodo (Arvore, Raiz, pairaiz) if Raiz == 0 painodo = pairaiz; altesq = AlturaArvore(Arvore, Arvore(Raiz).Esquerda); altdir = AlturaArvore(Arvore, Arvore(Raiz).Direita); if altesq < altdir painodo = DeterminarPaiNodo(Arvore, Arvore(Raiz).Esquerda, Raiz); elseif altesq > altdir painodo = DeterminarPaiNodo(Arvore, Arvore(Raiz).Direita, Raiz); else % alturas iguais, verificar qual tem mais nodos numnodosesq = NumeroNodosArvore(Arvore, Arvore(Raiz).Esquerda); numnodosdir = NumeroNodosArvore(Arvore, Arvore(Raiz).Direita); if numnododesq < numnodosdir else painodo = DeterminarPaiNodo(Arvore, Arvore(Raiz).Esquerda, Raiz); painodo = DeterminarPaiNodo(Arvore, Arvore(Raiz).Direita, Raiz); 26

27 Remover um elemento de uma árvore binária Considerar três casos distintos, segundo as características do nodo a remover: - se é uma folha, - se é um nodo com um único filho, ou - se é um nodo com dois filhos. Remoção de uma folha Remoção de um nodo com um único filho 27

28 Remoção de um nodo com dois filhos Este processo consiste em substituir este nodo por uma das folhas sua descendente: 1º) escolher uma das folhas descendente do nodo a remover que o irá substituir; 2º) substituir o elemento do nodo a ser removido pelo elemento da folha escolhida; 3º) remover a folha escolhida. Parâmetros: Entrada: elemento a remover (Elem), árvore (Arvore) e raiz da árvore (Raiz) Saída: árvore (Arvore) e raiz da árvore (Raiz) atualizadas 28

29 Algoritmo (iterativo): Determinar o índice do nodo com o elemento a remover Se o elemento não está na árvore Então SAIR Se o nodo com o elemento a remover tem 2 filhos (subárvores não nulas) Então Escolher a folha descendente do nodo com o elemento a remover que o irá substituir Substituir o elemento do nodo a ser removido pelo elemento da folha substituta Remover a folha substituta da árvore Libertar a folha substituta da árvore (do vetor da árvore) Se o nodo com o elemento a remover é uma folha (subárvores nulas) Então Remover o nodo com o elemento a remover da árvore Libertar o nodo removido do vetor da árvore Se o nodo a remover tem apenas filho esquerdo (não tem filho direito) Então Determinar o nodo pai do nodo com o elemento a remover Ligar o nodo pai ao nodo filho do nodo com o elemento a remover Se o nodo a remover tem apenas filho direito (não tem filho esquerdo) Então Determinar o nodo pai do nodo com o elemento a remover Ligar o nodo pai ao nodo filho do nodo com o elemento a remover 29

30 Função implementada em MatLab (iterativa): function [Arvore, Raiz] = RemoverElementoArvore (Elem, Arvore, Raiz) indnodo = PesquisarElementoArvore(Elem, Arvore, Raiz); if indnodo == 0 % Elem não está na árvore % se o nodo a remover tem 2 filhos if Arvore(indNodo).Esquerda ~= 0 & Arvore(indNodo).Direita ~= 0 folha = ProcurarFolhaArvore(Arvore, indnodo); paifolha = PesquisarPaiNodo(Arvore(folha).Elemento, Arvore, Raiz, 0); Arvore(indNodo).Elemento = Arvore(folha).Elemento; if Arvore(paiFolha).Esquerda == folha Arvore(paiFolha).Esquerda = 0; % remover a folha da árvore else Arvore(paiFolha).Direita = 0; [Arvore, Raiz] = LibertarNodoArvore(Arvore, Raiz, folha); % libertar a folha do vetor 30

31 % se o nodo a remover é uma folha if Arvore(indNodo).Esquerda == 0 & Arvore(indNodo).Direita == 0 painodo = PesquisarPaiNodo(Elem, Arvore, Raiz, 0); if painodo == 0 Raiz = 0; % árvore com apenas um elemento if Arvore(paiNodo).Esquerda == indnodo Arvore(paiNodo).Esquerda = 0; else Arvore(paiNodo).Direita = 0; [Arvore, Raiz] = LibertarNodoArvore(Arvore, Raiz, indnodo); 31

32 % se o nodo a remover tem apenas filho esquerdo (não tem filho direito) if Arvore(indNodo).Esquerda ~= 0 painodo = PesquisarPaiNodo(Elem, Arvore, Raiz, 0); if painodo == 0 Raiz = Arvore(Raiz).Esquerda; [Arvore, Raiz] = LibertarNodoArvore(Arvore, Raiz, indnodo); if Arvore(paiNodo).Esquerda == indnodo Arvore(paiNodo).Esquerda = Arvore(indNodo).Esquerda; else Arvore(paiNodo).Direita = Arvore(indNodo).Esquerda; [Arvore, Raiz] = LibertarNodoArvore(Arvore, Raiz, indnodo); 32

33 % o nodo a remover apenas tem filho direito (não tem filho esquerdo) painodo = PesquisarPaiNodo(Elem, Arvore, Raiz, 0); if painodo == 0 Raiz = Arvore(Raiz).Direita; [Arvore, Raiz] = LibertarNodoArvore(Arvore, Raiz, indnodo); if Arvore(paiNodo).Esquerda == indnodo Arvore(paiNodo).Esquerda = Arvore(indNodo).Direita; else Arvore(paiNodo).Direita = Arvore(indNodo).Direita; [Arvore, Raiz] = LibertarNodoArvore(Arvore, Raiz, indnodo); 33

34 Operações auxiliares da operação remover elemento de uma árvore: Operação: Determinar o pai (nodo) do nodo a remover Parâmetros: Entrada: elemento (Elem), árvore (Arvore), raiz da árvore (Raiz) e pai da raiz (pairaiz) Saída: o nodo pai do elemento dado (painodo) Função implementada em MatLab (iterativa): Nota: CompararElementos é uma operação específica do problema function [painodo] = PesquisarPaiNodo (Elem, Arvore, Raiz, pairaiz) if Raiz == 0 painodo = 0; if CompararElementos(Arvore(Raiz).Elemento, Elem) == 0 painodo = pairaiz; painodo = PesquisarPaiNodo(Elem, Arvore, Arvore(Raiz).Esquerda, Raiz); if painodo == 0 painodo = PesquisarPaiNodo(Elem, Arvore, Arvore(Raiz).Direita, Raiz); 34

35 Operação: Procurar a folha que irá substituir o nodo com o elemento a remover. Parâmetros: Entrada: árvore (Arvore), raiz da árvore (Raiz) e pai da raiz (pairaiz) Saída: a folha (nodo terminal) com o elemento que substituirá o elemento a remover (folha) Função implementada em MatLab (iterativa): function [folha] = ProcurarFolhaArvore (Arvore, Raiz, pairaiz) if Arvore(Raiz).Esquerda == 0 & Arvore(Raiz).Direita == 0 folha = Raiz; alturaesq = AlturaArvore(Arvore, Arvore(Raiz).Esquerda); alturadir = AlturaArvore(Arvore, Arvore(Raiz).Direita); if alturaesq > alturadir folha = ProcurarFolhaArvore(Arvore, Arvore(Raiz).Esquerda, Raiz); else folha = ProcurarFolhaArvore(Arvore, Arvore(Raiz).Direita, Raiz); 35

36 Determinar o maior elemento de uma árvore binária Notas: - a árvore não pode ser vazia, pois não existe maior elemento de uma árvore vazia. Parâmetros: Entrada: árvore (Arvore) e raiz da árvore (Raiz) Saída: maior elemento da árvore (maiorelem) Algoritmo (recursivo): Se a árvore tem apenas um elemento (a raiz é uma folha) Então Maior elemento elemento da raiz Se a árvore tem dois filhos Então Maior elemento maior { maior elemento da subárvore esquerda, maior elemento da subárvore direita, elemento da raiz } Se a árvore tem apenas filho esquerdo (não tem filho direito) Então Maior elemento maior { maior elemento da subárvore esquerda, elemento da raiz } Se a árvore tem apenas filho direito (não tem filho esquerdo) Então Maior elemento maior { maior elemento da subárvore direita, elemento da raiz } 36

37 Função implementada em MatLab (recursivo): function [maiorelem] = DeterminarMaiorElementoArvore (Arvore, Raiz) if Arvore(Raiz).Esquerda == 0 & Arvore(Raiz).Direita == 0 maiorelem = Arvore(Raiz).Elemento; if Arvore(Raiz).Esquerda ~= 0 & Arvore(Raiz).Direita ~= 0 maioresq = DeterminarMaiorElementoArvore(Arvore, Arvore(Raiz).Esquerda); maiordir = DeterminarMaiorElementoArvore(Arvore, Arvore(Raiz).Direita); % determinar o maior entre a raiz e os maiores das subárvores esquerda e direita maiorelem = MaiorEntreDoisElementos(Arvore(Raiz).Elemento, maioresq); maiorelem = MaiorEntreDoisElementos(maiorElem, maiordir); if Arvore(Raiz).Esquerda ~= 0 maioresq = DeterminarMaiorElementoArvore(Arvore, Arvore(Raiz).Esquerda); % determinar o maior entre a raiz e o maior da subárvore esquerda maiorelem = MaiorEntreDoisElementos(Arvore(Raiz).Elemento, maioresq); 37

38 if Arvore(Raiz).Direita ~= 0 maiordir = DeterminarMaiorElementoArvore(Arvore, Arvore(Raiz).Direita); % determinar o maior entre a raiz e o maior da subárvore esquerda maiorelem = MaiorEntreDoisElementos(Arvore(Raiz).Elemento, maiordir); function [maior] = MaiorEntreDoisElementos (Elem1, Elem2) if CompararElementos(Elem1, Elem2) >= 0 maior = Elem1; else maior = Elem2; 38

39 Verificar se duas árvores binárias são iguais Notas: - duas árvores são iguais se tiverem os mesmos elementos e nas mesmas posições. Parâmetros: Entrada: duas árvores (Arvore1 e Arvore2) e respetivas raízes (Raiz1 e Raiz2) Saída: 1 (se as árvores são iguais) ou 0 (se as árvores são diferentes) Algoritmo (recursivo): Se as duas árvores estão vazias Então As árvores são iguais Se uma das árvores está vazia e a outra não Então As árvores são diferentes Se as duas árvores são não vazias Então Se os elementos das raízes das árvores são diferentes OU as subárvores esquerdas são diferentes OU as subárvores direitas são diferentes Então As árvores são diferentes Senão As árvores são iguais 39

40 Função implementada em MatLab (recursiva): Nota: CompararElementos é uma operação específica do problema function [iguais] = ArvoresIguais (Arvore1, Raiz1, Arvore2, Raiz2) if Raiz1 == 0 & Raiz2 == 0 iguais = 1; % as duas árvores estão vazias, logo são iguais % se uma das árvores é vazia if Raiz1 == 0 Raiz2 == 0 iguais = 0; % uma das árvores está vazia e a outra não, logo são diferentes % as duas árvores são não vazias if CompararElementos(Raiz1.Elemento, Raiz2.Elemento) ~= 0 iguais = 0; % as raízes são diferentes, logo as árvores são diferentes 40

41 % comparar as subárvores esquerdas if ArvoresIguais(Arvore1, Arvore1(Raiz1).Esquerda, Arvore2, Arvore2(Raiz2).Esquerda) ~= 0 iguais = 0; % as subárvores esquerdas são diferentes % comparar as subárvores direitas if ArvoresIguais(Arvore1, Arvore1(Raiz1).Direita, Arvore2, Arvore2(Raiz2).Direita) ~= 0 iguais = 0; % as subárvores direitas são diferentes iguais = 1; % as árvores são iguais 41

42 Alterar/atualizar um elemento de uma árvore binária Nota: - A informação contida no elemento fornecido para atualizar basta incidir sobre um dos seus campos, normalmente o que serve de Chave (valor que caracteriza o elemento). Parâmetros: Entrada: elemento a alterar (Elem), árvore (Arvore) e raiz da árvore (Raiz) Saída: árvore atualizada com a nova informação sobre o Elem (Arvore) Função implementada em MatLab (iterativa): Nota: AlterarElemento é uma operação específica do problema function [Arvore] = AlterarElementoArvore (Elem, Arvore, Raiz) indnodo = PesquisarElementoArvore(Elem, Arvore, Raiz); if indnodo ~= 0 Arvore(indNodo).Elemento = AlterarElemento(Arvore(indNodo).Elemento); 42

43 Trocar dois elementos de uma árvore binária Nota: - A informação contida nos elementos de entrada para trocar basta incidir sobre um dos seus campos, normalmente o que serve de Chave (valor que caracteriza o elemento). Parâmetros: Entrada: elementos a trocar (Elem1 e Elem2), árvore (Arvore) e raiz da árvore (Raiz) Saída: árvore atualizada com os elementos trocados (Arvore) Função implementada em MatLab (iterativa): function [Arvore] = TrocarElementosArvore (Elem1, Elem2, Arvore, Raiz) indnodo1 = PesquisarElementoArvore(Elem1, Arvore, Raiz); indnodo2 = PesquisarElementoArvore(Elem2, Arvore, Raiz); if indnodo1 ~= 0 & indnodo2 ~= 0 auxelem = Arvore(indNodo1).Elemento; Arvore(indNodo1).Elemento = Arvore(indNodo2).Elemento; Arvore(indNodo2).Elemento = auxelem; 43

44 Exemplo 1: Lista em que o elemento de cada nodo é um inteiro. Estrutura de dados: Arvore(k) = struct { Elemento, Esquerda, Direita }, k = 1,... Arvore é um tipo de dados estruturado (neste caso, do tipo registo); Elemento é um tipo não estruturado básico (neste caso, do tipo inteiro). Operações específicas deste problema a implementar (funções em MatLab): function [Elem] = CriarElemento () Elem = input('inserir um inteiro: '); function [] = MostrarElemento(Elem) disp(elem); function [Elem] = AlterarElemento (Elem) disp(elem); sim = input('pretende alterar este valor (1 = sim; 0 = nao)? '); if sim == 1 Elem = input('inserir um inteiro: '); 44

45 % comparar dois elementos considerando para comparação os valores dos elementos function [comp] = CompararElementos (Elem1, Elem2) if Elem1 > Elem2 comp = 1; elseif Elem1 == Elem2 comp = 0; else comp = -1; 45