CES-11 ALGORITMOS E ESTRUTURAS DE DADOS Capítulo IV Árvores Gerais

Capítulo IV – Árvores Gerais 4.1 – Definições e terminologia básica 4.2 – Formas de representação de árvores 4.3 – Ordenação dos nós de uma árvore 4.4 – Operadores para o TAD árvore 4.5 – Estruturas contíguas para árvores 4.6 – Estruturas encadeadas para árvores

4.1 – Definições e Terminologia Básica 4.1.1 – O TAD árvore Forma natural de representação

Cada elemento é armazenado em um nó O TAD Árvore: Cada elemento é armazenado em um nó Sobre os nós existe uma hierarquia paterna Entre alguns pares, existe a relação “pai de” A é pai de B, C e D D é pai de H C é pai de F e G etc.

Raiz: nó de máxima hierarquia de uma árvore Abaixo, A é a raiz Cada nó tem um e apenas um pai (exceto a raiz) Cada nó tem zero ou mais filhos Um nó não pode ter um ancestral como filho Exemplo: I não pode ser pai de H, D ou A

4.1.2 – Definição recursiva de Árvore Um único nó é por si mesmo uma árvore; ele é a raiz dessa árvore Sejam A1, A2, ... , Ak, árvores de raízes n1, n2, ..., nk, respectivamente, e n um nó não pertencente a nenhuma delas Fazendo n pai de n1, n2, ..., nk, obtém-se uma nova árvore n nk Ak n1 A1 n2 A2 n3 A3

Mostrar que a seguinte figura é uma árvore: H G F D C E B K J I

I, J e K são por si só árvores; fazendo H pai das raízes I, J e K, obtém-se nova árvore F, G e E são por si só árvores; fazendo B pai de E, C pai de F e G, e D pai de H, obtém-se novas árvores Fazendo A pai de B, C e D, obtém-se nova árvore A B C D E F G H I J K

4.1.3 – Outras definições relativas a árvores Árvore nula: árvore sem nós (representada por ) Caminho de um nó n1 para outro nk: sequência de nós n1, n2, n3, . . ., nk-1, nk, tais que ni é pai de ni+1 (1  i < k) O caminho pode ter um nó apenas (n1 = nk) Caminhos: A, AB, ABE, AC, ACG, CF, ADHJ, D, ADHK, DH, DHI, etc.

Comprimento de um caminho: número de nós do caminho menos 1 Comprimento dos caminhos: A = 0 BE = 1 ABE = 2 ADHJ = 3 DHI = 2

Um nó é ancestral e descendente de si mesmo Se há um caminho de ni para nj, ni é ancestral de nj e nj é descendente de ni Um nó é ancestral e descendente de si mesmo Ancestral próprio ou descendente próprio de um nó é um ancestral ou descendente, respectivamente, diferente daquele nó Ancestrais próprios de J: A, D, H Descendentes próprios de D: H, I, J, K

A raiz não possui ancestral próprio Folha: nó sem filhos, ou então, nó com nenhum descendente próprio (também chamado nó-terminal) Folhas: E, F, G, I, J, K

Altura de uma árvore é a altura de sua raiz Altura de um nó: comprimento do mais longo caminho do nó a alguma folha Altura de uma árvore é a altura de sua raiz Profundidade ou nível de um nó: comprimento do caminho da raiz ao nó Altura de D = 2 Altura da árvore = 3 Profundidade de D = 1

Grau de um nó: número de sub-árvores disjuntas ou de filhos do nó Irmãos: filhos de um mesmo nó Nó não-terminal: nó não folha Grau de A = 3 Grau de D = 1 Grau de G = 0 B, C, D são irmãos E não tem irmãos Nós não-terminais: A, B, C, D, H

Floresta: conjunto de zero ou mais árvores disjuntas Exemplo:

Capítulo IV – Árvores Gerais 4.1 – Definições e terminologia básica 4.2 – Formas de representação de árvores 4.3 – Ordenação dos nós de uma árvore 4.4 – Operadores para o TAD árvore 4.5 – Estruturas contíguas para árvores 4.6 – Estruturas encadeadas para árvores

4.2 – Formas de Representação de Árvores 4.2.1 – Forma natural

4.2.2 – Diagramas de conjuntos

(A (B (E)) (C (F) (G)) (D (H (I) (J) (K))) ) 4.2.3 – Forma parentética Coloca-se entre parêntesis: primeiramente a raiz, depois as formas parentéticas das sub-árvores da raiz ordenadas da esquerda para a direita (recursividade): (A (B (E)) (C (F) (G)) (D (H (I) (J) (K))) ) Forma usada para representar uma árvore em que cada elemento é um caractere

Forma parentética: definição recursiva Sendo c um caractere genérico, (c) é uma forma parentética correta Se α1, α2, α3, ... αn, são formas parentéticas corretas (n > 0), então (c α1α2α3 ... αn) também é

4.2.4 – Forma tabulada Diretoria Departamento de Fabricação Seção de Prensas Seção de Tornos Seção de Ferramentaria Seção de Fornos Seção de Banhos Químicos Departamento de Engenharia de Produção Seção de Desenvolvimento de Projetos Seção de Desenhos Seção de Controle de Qualidade Departamento de Manutenção Seção de Eletricistas Seção de Mecânica Seção de Hidráulica Seção de Instalações Prediais Departamento de Administração Seção de Pessoal Seção de Finanças Seção de Planejamento Cada nó aparece numa linha e os filhos de um nó são listados com uma tabulação a mais que a desse nó Exemplo: organograma de uma fábrica

4.2.5 – Forma numerada A numeração do filho de um nó tem como prefixo o número desse nó e como sufixo um número para o distinguir de seus irmãos Exemplo a seguir: organização de uma apostila

1 – Estruturas de dados 1.4 – Ordenação e Procura 1.1 – Listas lineares 1.1.1 – Estrutura contígua 1.1.2 – Estrutura encadeada 1.1.3 – Pilhas e filas 1.2 – Árvores 1.2.1 – Definições 1.2.2 – Estruturas de dados 1.2.3 – Árvores binárias 1.3 – Grafos 1.3.1 – Grafos orientados 1.3.2 – Grafos não orientados 1.4 – Ordenação e Procura 1.4.1 – Métodos de ordenação 1.4.1.1 – Métodos elementares 1.4.1.2 – Método quick-sort 1.4.1.3 – Método heap-sort 1.4.1.4 – Método merge-sort 1.4.2 – Métodos de procura 1.4.2.1 – Procura sequencial 1.4.2.2 – Procura binária 1.4.2.3 – Procura hashing 1.4.2.4 – Árvores binárias de procura

Capítulo IV – Árvores Gerais 4.1 – Definições e terminologia básica 4.2 – Formas de representação de árvores 4.3 – Ordenação dos nós de uma árvore 4.4 – Operadores para o TAD árvore 4.5 – Estruturas contíguas para árvores 4.6 – Estruturas encadeadas para árvores

4.3 – Ordenação dos Nós de uma Árvore 4.3.1 – Ordenação dos filhos de um nó Os filhos de um nó são ordenados da esquerda para a direita As duas árvores abaixo têm o mesmo pai e os mesmos filhos, mas são diferentes

Filho esquerdo de um nó é o filho mais à esquerda desse nó (primogênito) B é o filho esquerdo de A F é o filho esquerdo de C H é o filho esquerdo de D

Irmão direito de um nó é o irmão imediatamente à direita desse nó Nó sem irmão direito é chamado de caçula C é o irmão direito de B K é o irmão direito de J H, G, K são caçulas E é primogênito e caçula

4.3.2 – Extensão da ordenação da esquerda para a direita Se A e B são irmãos e B está à direita de A, então todos os descendentes de B estão à direita de todos os descendentes de A Exemplo: C e D são irmãos e C está à esquerda de D, logo C, F e G estão à esquerda de D, H, I, J, K J não está nem à direita nem à esquerda de H, D, e A

4.3.3 – Ordenação de todos os nós de uma árvore Existem formas de se ordenar e/ou de se percorrer sistematicamente todos os nós de uma árvore As formas mais conhecidas são: Ordenação ou caminhamento por nível Ordenação ou caminhamento em pré-ordem Ordenação ou caminhamento em pós-ordem Ordenação ou caminhamento em ordem-central (também conhecida como in-ordem)

a) Ordenação ou caminhamento por nível Primeiramente visita-se a raiz Depois visita-se todos os filhos da raiz, da esquerda para a direita Depois os netos, depois os bis-netos da raiz, e assim por diante A A B C D E F G H I J K A B C D Também é chamada busca ou caminhamento em largura

b) Ordenações ou caminhamentos em pré, pós-ordem e ordem-central Também chamadas buscas ou caminhamentos em profundidade Podem ser definidas de forma recursiva (vista mais adiante)

Esquema gráfico para definir pré, pós-ordem e ordem- central:

Pré-ordem: anotar o nó ao passar por ele pela 1ª vez Pós-ordem: anotar o nó ao passar por ele pela última vez, ou seja, ao se dirigir para seu pai Ordem-central: anotar um nó folha ao passar por ele pela 1ª vez e um nó não-terminal ao passar por ele pela 2a vez

Exemplo: pré-ordem, pós-ordem e ordem-central da árvore abaixo: Pré-ordem: A BE CFG D HIJK Pós-ordem: EB FGC IJKH D A Ordem-central: EB A FCG IHJK D

Definição recursiva de pré, pós-ordem e ordem-central: Se A é uma árvore nula, então uma lista vazia é a ordenação ou listagem em pré-ordem, pós-ordem e ordem-central de A Se A consiste de um nó apenas, esse nó é a ordenação ou listagem em pré-ordem, pós-ordem e ordem-central de A

Em outros casos: seja A uma árvore de raiz n e sub-árvores A1, A2, Em outros casos: seja A uma árvore de raiz n e sub-árvores A1, A2, ..., Ak n1 A1 n2 A2 n3 A3 nk Ak n

Ordenação, listagem ou caminhamento em pré-ordem dos nós de A é: Primeiramente a raiz n de A Seguida dos nós de A1 em pré-ordem Seguidos dos nós de A2 em pré-ordem, etc. Até os nós de Ak em pré-ordem n1 A1 n2 A2 n3 A3 nk Ak n

Ordenação, listagem ou caminhamento em pós-ordem dos nós de A é: Primeiramente os nós de A1 em pós-ordem Seguidos dos nós de A2 em pós-ordem, etc. Até os nós de Ak em pós-ordem Seguidos da raiz n de A n1 A1 n2 A2 n3 A3 nk Ak n

Ordenação, listagem ou caminhamento em ordem-central dos nós de A é: Primeiramente os nós de A1 em ordem-central Seguidos da raiz n de A Seguida dos nós de A2 ,..., Ak em ordem-central n1 A1 n2 A2 n3 A3 nk Ak n

Esquemas de funções para pré-ordem, pós-ordem e ordem-central: void PreOrdem (noh n) { Escrever (n); para (cada filho c de n, da esquerda para a direita) PreOrdem (c); } n1 A1 n2 A2 n3 A3 nk Ak n

Esquemas de funções para pré-ordem, pós-ordem e ordem-central: void PosOrdem (noh n) { para (cada filho c de n, da esquerda para a direita) PosOrdem (c); Escrever (n); } n1 A1 n2 A2 n3 A3 nk Ak n

Esquemas de funções para pré-ordem, pós-ordem e ordem-central: void OrdCentral (noh n) { se (n é folha) Escrever (n); senao { OrdCentral (Filho esquerdo de n); Escrever (n); para (cada filho c de n, exceto o esquerdo, da esquerda para a direita) OrdCentral (c); } n1 A1 n2 A2 n3 A3 nk Ak n

Capítulo IV – Árvores Gerais 4.1 – Definições e terminologia básica 4.2 – Formas de representação de árvores 4.3 – Ordenação dos nós de uma árvore 4.4 – Operadores para o TAD árvore 4.5 – Estruturas contíguas para árvores 4.6 – Estruturas encadeadas para árvores

4.4 – Operadores para o TAD Árvore noh Pai (n, A): retorna o pai do nó n da árvore A   Se n é raiz, Pai é nulo noh FilhoEsquerdo (n, A): retorna o filho-esquerdo do nó n na árvore A   Se n é folha, FilhoEsquerdo é nulo As declarações dos tipos Arvore, noh e da constante nulo dependem da estrutura de dados usada para implementar árvores

noh IrmãoDireito (n, A): retorna o irmão-direito do nó n na árvore A Se n é caçula, IrmãoDireito é nulo logic Cacula (n, A): verifica se o nó n é caçula na árvore A tipelemento Elemento (n, A): retorna o conteúdo em informações do nó n da árvore A Os nós de uma árvore podem não conter informação alguma No entanto há casos em que cada nó contém uma estrutura complexa

Arvore Criação (x, ListaÁrvores): coloca a informação de x num novo nó n, cria e retorna uma árvore com raiz n e subárvores da raiz pertencentes à ListaÁrvores (Lista linear de árvores) n A x A E B G F C H D K J I ListaÁrvores

noh Raiz (A): retorna o nó raiz da árvore A void Esvaziar (A): torna vazia a árvore A logic Vazia (A): verifica se a árvore A é vazia ou não Arvore NovaArvore (): forma interativamente uma nova árvore, retornando-a Devido a problemas de eficiência, é conveniente que esta função seja dependente da estrutura de dados para árvores

Muitas outras operações podem ser definidas, dependendo da aplicação: Alterar o conteúdo de um nó Fazer um novo nó ser caçula de outro nó Fazer uma árvore ser uma sub-árvore de um nó de outra árvore Deletar uma sub-árvore de um nó Deletar um nó de uma árvore (complicado se não for folha) Inserir um nó numa árvore (em que posição?) Essas operações podem ser usadas para criar funções independentes de estrutura

Exemplo: Listagem em pré-ordem de uma sub-árvore cuja raiz é o nó n de uma árvore A void PreOrdem (noh n, arvore A) { noh c; Escrever (Elemento (n, A)); c = FilhoEsquerdo (n, A); while (c != nulo) { PreOrdem (c, A); c = IrmaoDireito (c, A); } A pré-ordem da árvore A é obtida pela chamada: PreOrdem (Raiz (A), A)

Exemplo: Cálculo da altura de uma árvore A Definição recursiva da altura de um nó n: Se n é nulo, Altura (n) = -1 Senão, se n é folha, Altura (n) = 0 Senão Altura (n) = 1 + max (Alturas dos filhos de n) Para a árvore A, basta calcular Altura (Raiz (A)) Altura de um nó n: Comprimento do mais longo caminho de n a alguma folha

int Altura (noh n, arvore A) { int maxalt, aux; noh f; if (n == nulo) return -1; f = FilhoEsquerdo (n, A); if (f == nulo) return 0; for (maxalt = 0; f != nulo; f = IrmaoDireito (f, A)) { aux = Altura (f, A); if (aux > maxalt) maxalt = aux; } return maxalt + 1;

Exemplo: Número de folhas de uma árvore A Definição recursiva do número de folhas da sub-árvore cuja raiz é um nó n: Se n é nulo, NFolhas (n) = 0 Senão, se n é folha, NFolhas (n) = 1 Senão NFolhas (n) =  (NFolhas (cada filho de n)) Para a árvore A, basta calcular NFolhas (Raiz (A))

int NumFolhas (noh n, arvore A) { int nf; noh f; if (n == nulo) return 0; f = FilhoEsquerdo (n, A); if (f == nulo) return 1; for (nf = 0; f != nulo; f = IrmaoDireito (f, A)) { nf += NumFolhas (f, A); } return nf;

Exemplo: Listagem dos nós por ordem de nível Dada uma árvore como aquela abaixo, escrever na tela: A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) I(H) J(H) K(H) Cada nível numa linha da tela Cada nó seguido de seu pai, entre parêntesis

fs (fila secundária): para enfileirar os filhos dos nós da fila fp Idéia: Usar duas filas fp (fila principal): para guardar os nós de uma linha (nível) a ser escrita fs (fila secundária): para enfileirar os filhos dos nós da fila fp Para cada nó da fila fp : Escrevê-lo na tela seguido de seu pai entre “( )” Colocar seus filhos na fila fs Até que ambas as filas fiquem vazias

Inicializar fs e nela entrar com a raiz:

Copiar fs em fp e reinicializar fs:

Deletar em fp, copiando sua frente no nó avulso x: fs A x fp A

Escrever o conteúdo de x, com seu pai entre parêntesis: fs A x fp A(#)

Entrar com os filhos de x em fs: B C D A x fp A(#)

Como fp está vazia, mas fs não está, mudar de linha na tela: B C D A x fp A(#) A(#)

Copiar fs em fp e reinicializar fs: B C D x A fp B C D A(#)

Deletar em fp, copiando sua frente no nó avulso x: fs x B A fp B C D A(#)

Escrever o conteúdo de x, com seu pai entre parêntesis: fs B x fp C D A(#) A(#) B(A)

Entrar com os filhos de x em fs: B x fp C D A(#) B(A)

Como fp não está vazia, deletar em fp, copiando sua frente no nó avulso x: fs E x B C fp C D A(#) B(A)

Escrever o conteúdo de x, com seu pai entre parêntesis: fs E C x fp D A(#) B(A) A(#) B(A) C(A)

Entrar com os filhos de x em fs: G C x fp D A(#) B(A) C(A)

Como fp não está vazia, deletar em fp, copiando sua frente no nó avulso x: fs E F G x C D fp D A(#) B(A) C(A)

Escrever o conteúdo de x, com seu pai entre parêntesis: fs E F G D x fp A(#) B(A) C(A) A(#) B(A) C(A) D(A)

Entrar com os filhos de x em fs: G H D x fp A(#) B(A) C(A) D(A)

Como fp está vazia, mas fs não está, mudar de linha na tela: G H D x fp A(#) B(A) C(A) D(A) A(#) B(A) C(A) D(A)

Copiar fs em fp e reinicializar fs: G H D x fp E F G H A(#) B(A) C(A) D(A)

Deletar em fp, copiando sua frente no nó avulso x: fs x D E fp E F G H A(#) B(A) C(A) D(A)

Escrever o conteúdo de x, com seu pai entre parêntesis: fs E x fp F G H A(#) B(A) C(A) D(A) A(#) B(A) C(A) D(A) E(B)

Como x não tem filhos para entrar em fs e como fp não está vazia, deletar em fp, copiando sua frente no nó avulso x: fs x E F fp F G H A(#) B(A) C(A) D(A) E(B)

Escrever o conteúdo de x, com seu pai entre parêntesis: fs F x fp G H A(#) B(A) C(A) D(A) E(B) A(#) B(A) C(A) D(A) E(B) F(C)

Como x não tem filhos para entrar em fs e como fp não está vazia, deletar em fp, copiando sua frente no nó avulso x: fs x F G fp G H A(#) B(A) C(A) D(A) E(B) F(C)

Escrever o conteúdo de x, com seu pai entre parêntesis: fs G x fp H A(#) B(A) C(A) D(A) E(B) F(C) A(#) B(A) C(A) D(A) E(B) F(C) G(C)

Como x não tem filhos para entrar em fs e como fp não está vazia, deletar em fp, copiando sua frente no nó avulso x: fs x G H fp H A(#) B(A) C(A) D(A) E(B) F(C) G(C)

Escrever o conteúdo de x, com seu pai entre parêntesis: fs H x fp A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) A(#) B(A) C(A) D(A) E(B) F(C) G(C)

Entrar com os filhos de x em fs: J K H x fp A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D)

Como fp está vazia, mas fs não está, mudar de linha na tela: J K H x fp A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D)

Copiar fs em fp e reinicializar fs: J K H x fp I J K A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D)

Deletar em fp, copiando sua frente no nó avulso x: fs x I H fp I J K A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D)

Escrever o conteúdo de x, com seu pai entre parêntesis: fs I x fp J K A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) I(H)

Como x não tem filhos para entrar em fs e como fp não está vazia, deletar em fp, copiando sua frente no nó avulso x: fs x I J fp J K A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) I(H)

Escrever o conteúdo de x, com seu pai entre parêntesis: fs J x fp K A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) I(H) A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) I(H) J(H)

Como x não tem filhos para entrar em fs e como fp não está vazia, deletar em fp, copiando sua frente no nó avulso x: fs x K J fp K A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) I(H) J(H)

Escrever o conteúdo de x, com seu pai entre parêntesis: fs K x fp A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) I(H) J(H) A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) I(H) J(H) K(H)

Encerrar o processo pois ambas as filas estão vazias fs K x fp A(#) B(A) C(A) D(A) E(B) F(C) G(C) H(D) I(H) J(H) K(H)

void EscreverNiveis (arvore A) { fila fp, fs; noh x, y, pai; if (ArvVazia (A) == TRUE) write (" Arvore vazia"); else { InitFila (&fs); EntrarFila (Raiz (A), &fs); do { copiar (&fp, fs); InitFila (&fs); while (FilaVazia(fp) == FALSE) { x = DeletarFila(&fp); EscreverNoh (Elemento (x, A)); pai = Pai (x, A); write ("("); if (pai == vazio) write ("#"); else EscreverNoh (Elemento (pai, A)); write (") "); for (y = FilhoEsquerdo (x, A); y != nulo; y = IrmaoDireito(y, A)) EntrarFila (y, &fs); } write ("\n"); } while (FilaVazia(fs) == FALSE); Obs: a função DeletarFila deleta o elemento da frente da fila e retorna esse elemento