CES-11 ALGORITMOS E ESTRUTURAS DE DADOS Aulas Práticas

Apresentação em tema: "CES-11 ALGORITMOS E ESTRUTURAS DE DADOS Aulas Práticas"— Transcrição da apresentação:

1 CES-11 ALGORITMOS E ESTRUTURAS DE DADOS Aulas Práticas - 2016
Capítulo IV Árvores

2 O programa a ser desenvolvido neste capítulo irá:
Formar uma floresta através da digitação de todos os pares pais-filhos Formar uma nova árvore em que a informação da raiz é digitada e as sub-árvores da raiz serão as árvores da floresta formada anteriormente A estrutura de dados para árvores é o encadeamento de pais e irmãos A floresta deve ser uma lista linear encadeada de árvores

3 Exemplo: o operador fornece os seguintes pares:
A ordem entre dois irmãos é estabelecida pela ordem fornecida pelo operador Um filho não pode aparecer em mais de um par Não pode haver ciclos; Exemplo: Pai-Filho C-F R-S L-M R-T A-B C-G A-C N-P L-N A-D Pai-Filho A-B B-C C-D D-A

4 Floresta formada: Pai-Filho C-F R-S L-M R-T A-B C-G A-C N-P L-N A-D A

5 Exercício 4.1: Formar uma lista linear com todos os nós de uma floresta
Seja uma floresta em que as informações de cada nó é um caractere O caractere de um nó só pode ser letra (maiúscula ou minúscula) ou dígito decimal Não pode haver na floresta dois nós com o mesmo caractere

6 O exercício consiste em:
Ler uma string com os caracteres de todos os nós de uma floresta Armazenar cada caractere válido numa célula de árvore conforme o encadeamento de pais e irmãos Formar uma lista linear encadeada de ponteiros para cada célula criada acima (é uma lista de nós) Na realidade, formar-se-á uma floresta de árvores unitárias

7 Exemplo: O operador fornece a seguinte string: A7b;H*bk
Deve ser formada a seguinte lista linear: Na realidade, F será uma floresta de 5 árvores unitárias Para este exercício, completar o esqueleto de programa a seguir F # ● árvores A ● 7 ● b ● H ● k ●

8 info pai fesq idir celula #include <stdio.h>
#include <stdlib.h> #include <conio.h> #include <string.h> #include <ctype.h> typedef char logic; const logic TRUE = 1, FALSE = 0; /* Declaracoes de tipos para encadeamento de pais e irmaos para arvores */ typedef struct celula celula; const celula *nulo = NULL; typedef char informacao; typedef celula *noh; typedef celula *arvore; struct celula {informacao info; noh pai, fesq, idir;}; info pai fesq idir celula

9 Filas de nós são usadas:
/* Declaracoes de tipos para estrutura encadeada de filas de nohs de arvores */ typedef struct celfila celfila; typedef struct fila fila; struct celfila {noh elem; celfila *prox;}; struct fila {celfila *fr, *tr;}; Cada elemento da fila é um noh (ponteiro para celula) Filas de nós são usadas: Na função para escrever a árvore por ordem de nível (EscreverNiveis) Em eventuais funções que façam busca em largura na árvore A função EscreverNiveis é fornecida logo a seguir

10 typedef char string[100]; typedef struct celfloresta celfloresta;
/* Declaracoes de tipos para floresta, que eh uma lista encadeada de arvores, com elemento-lider */ typedef char string[100]; typedef struct celfloresta celfloresta; typedef struct celfloresta *floresta; typedef struct celfloresta *posicfloresta; struct celfloresta { arvore elem; celfloresta *prox; }; Para guardar a string digitada pelo operador Cada elemento da lista é uma arvore (ponteiro para celula) # A ● 7 b H k F

11 /* Variaveis globais */
floresta F; string StrFloresta; // guarda os caracteres digitados /* Prototipos das funcoes dependentes da estrutura para arvores */ void FormarListaNohs (void); void EscreverFloresta (void); /* Prototipos das funcoes operadoras de arvores */ logic ArvVazia (arvore); informacao Elemento (noh, arvore); void EscreverNoh (informacao); noh Raiz (arvore); noh Pai (noh, arvore); noh FilhoEsquerdo (noh, arvore); noh IrmaoDireito (noh, arvore); Estas funções deverão ser programadas Estas funções foram dadas em aulas teóricas e são fornecidas mais adiante

12 /* Prototipos das funcoes independentes da estrutura para arvores */
void EscreverNiveis (arvore); /* Prototipos das funcoes operadoras de filas */ void InitFila (fila *); void EntrarFila (noh, fila *); noh DeletarFila (fila *); char FilaVazia (fila); Todas estas funções foram dadas em aulas teóricas e são fornecidas mais adiante

13 /* Programa principal: le, forma e escreve uma floresta */
int main () { printf ( "Leitura e armazenamento dos nohs da floresta F:\n\n" ); FormarListaNohs (); printf ("\n\nArvores da floresta F:\n\n"); EscreverFloresta (); printf ("\n\n"); system ("pause"); return 0; } As funções FormarListaNohs e EscreverFloresta devem ser dependentes da estrutura de dados para florestas e árvores

14 A string digitada deve ser guardada na variável StrFloresta
/* Funcao FormarListaNohs: le as informacoes dos nohs de uma floresta armazenando-as em celulas; forma uma lista linear de nohs ponteiros para essas celulas; essa lista eh a floresta F (global) */ void FormarListaNohs () { } A função deve pedir ao operador que digite uma string com os caracteres de todos os nós da floresta A string digitada deve ser guardada na variável StrFloresta

15 /. Funcao FormarListaNohs: le as informacoes dos nohs
/* Funcao FormarListaNohs: le as informacoes dos nohs de uma floresta armazenando-as em celulas; forma uma lista linear de nohs ponteiros para essas celulas; essa lista eh a floresta F (global) */ void FormarListaNohs () { } A lista deve ter um elemento-líder (para facilitar a deleção de uma celfloresta) # ● F A ● 7 ● b ● H ● k ●

16 /. Funcao FormarListaNohs: le as informacoes dos nohs
/* Funcao FormarListaNohs: le as informacoes dos nohs de uma floresta armazenando-as em celulas; forma uma lista linear de nohs ponteiros para essas celulas; essa lista eh a floresta F (global) */ void FormarListaNohs () { } Os caracteres não-letras, não-dígitos e os repetidos devem ser descartados; não precisa de mensagem de erro # A ● 7 b H k F

17 Para cada árvore da floresta, chamar a função EscreverNiveis
/* Funcao EscreverFloresta: escreve os nos de todas as arvores da floresta F em ordem de nivel */ void EscreverFloresta () { } Para cada árvore da floresta, chamar a função EscreverNiveis Neste exercício, as árvores só terão o nó-raiz, mas no próximo exercício poderão ter mais nós # A ● 7 b H k F

18 Função EscreverNiveis: escreve os nos da árvore A em ordem de nível
void EscreverNiveis (arvore A) { fila fp, fs; noh x, y, pai; if (ArvVazia (A) == TRUE) printf (" Arvore vazia"); else { InitFila (&fs); EntrarFila (Raiz (A), &fs); do { fp = fs; while (FilaVazia(fp) == FALSE) { x = DeletarFila(&fp); EscreverNoh (Elemento (x, A)); pai = Pai (x, A); printf ("("); if (pai == nulo) EscreverNoh ('#'); else EscreverNoh (Elemento (pai, A)); printf (") "); for (y = FilhoEsquerdo (x, A); y != nulo; y = IrmaoDireito(y, A)) EntrarFila (y, &fs); } printf ("\n"); } while (FilaVazia(fs) == FALSE); printf ("\n\n"); Função EscreverNiveis: escreve os nos da árvore A em ordem de nível Já foi apresentada em aula teórica

19 /* Funcoes operadoras de arvores */
logic ArvVazia (arvore A) { if (A == NULL) return TRUE; else return FALSE; } informacao Elemento (noh n, arvore A) {return n->info;} void EscreverNoh (informacao info) {printf ("%c", info);} noh Raiz (arvore A) {return A;} noh Pai (noh n, arvore A) {return n->pai;} noh FilhoEsquerdo (noh n, arvore A) {return n->fesq;} noh IrmaoDireito (noh n, arvore A) {return n->idir;} Já foram apresentadas em aula teórica

20 Também já foram apresentadas em aula teórica
/* Funcoes operadoras de filas de nos de arvores */ void InitFila (fila *f) { f->fr = malloc (sizeof(celfila)); f->tr = f->fr; f->fr->prox = NULL; } void EntrarFila (noh x, fila *f) { f->tr->prox = malloc (sizeof(celfila)); f->tr = f->tr->prox; f->tr->elem = x; f->tr->prox = NULL; noh DeletarFila (fila *f) { noh x; celfila *p; p = f->fr->prox; x = p->elem; if (f->tr == p) f->tr = f->fr; f->fr->prox = p->prox; free (p); return x; char FilaVazia (fila f) { char c; if (f.fr == f.tr) c = TRUE; else c = FALSE; return c; Também já foram apresentadas em aula teórica Os elementos das filas serão noh’s (ponteiros para celula)

21 Exercício 4.2: Fazer as ligações de todos os pais e filhos da floresta
Alterar o programa anterior, para que ele leia todos os pares pais-filhos da floresta Para cada par válido, a célula do filho deve ser ligada à do pai e deve ser colocada como caçula dos filhos desse pai Manter na lista formada no exercício anterior apenas os nós que forem raízes de árvores A floresta terá menos árvores, porém maiores

22 Exemplo: seja a seguinte floresta obtida no exercício anterior:
Supondo que o operador forneça os seguintes pares pais-filhos: BE, CF, CG # B ● C G E F Deve ter somente 2 caracteres (diferentes entre si) Pai e filho devem estar em alguma célula da floresta O filho aparece pela 1ª vez como filho O filho não é um ancestral do pai Par válido

23 Deverão ser feitas as seguintes ligações:
Supondo que o operador forneça os seguintes pares pais-filhos: BE, CF, CG Deverão ser feitas as seguintes ligações: # B ● C G E F ● ● ● ● ● ●

24 Desenhando de outra forma:
Os nós que não forem raízes (ou seja, aqueles que tiverem pai) devem ser retirados da floresta F Desenhando de outra forma: F # B ● C ● G ● E ● F ●

25 # B ● C G E F ● A floresta F passou de 5 árvores unitárias para 2 árvores, uma com 2 e outra com 3 nós

26 Novo programa principal:
int main () { printf ( "Leitura e armazenamento dos nohs da floresta F:\n\n" ); FormarListaNohs (); if (F->prox != NULL) { "\nLeitura e ligacao dos pares pais-filhos:\n\n"); LigarPaisFilhos (); } printf ("\n\nArvores da floresta F:\n\n"); EscreverFloresta (); printf ("\n\n"); system ("pause"); return 0;

27 A função LigarPaisFilhos deverá ler vários pares pais-filhos e, para cada par:
Checar se o par é válido Se for válido, ligar a célula do filho à do pai Inserir a célula do filho como caçula do pai No final, a função deverá retirar da lista linear (floresta F) todos os nós que não forem raízes

28 Exercício 4.3: Formar uma nova árvore em que as sub-árvores da raiz deverão ser as árvores da floresta F Alterar o programa anterior, para que ele: Leia uma nova informação (caractere) Guarde essa informação numa célula Faça um ponteiro para essa célula ser a raiz de uma nova árvore Faça as árvores da floresta F serem sub-árvores dessa raiz Escreva na tela essa nova árvore em ordem de nível

29 Exemplo: seja a floresta anterior
# B ● C G E F

30 Nova árvore: A X ● ● # B C ● G E F ● ● ●

31 Novo programa principal
int main () { informacao c; arvore A; printf ( "Leitura e armazenamento dos nohs da floresta F:\n\n“); FormarListaNohs (); if (F->prox != NULL) { "\nLeitura e ligacao dos pares pais-filhos:\n\n"); LigarPaisFilhos (); } printf ("\n\nArvores da floresta F:\n\n"); EscreverFloresta (); printf ("\n\nCriacao de nova arvore:\n\n\t"); printf ("Digite a informacao da raiz: "); c = getche (); A = Criacao (c, F); printf ("\n\n"); EscreverNiveis (A); printf ("\n\n"); system ("pause"); return 0; Novo programa principal A função Criacao deve ser dependente das estruturas de dados para árvores e florestas

32 Exercício 4.4: Forma parentética, altura, largura e número de nós das árvores
Alterar o programa anterior, para que ele escreva, para cada árvore da floresta e para a árvore final: Sua forma parentética Sua altura, largura e número de nós Largura de uma árvore é o máximo entre os números de nós de seus níveis Para cada um desses 4 itens, fazer uma função independente da estrutura de dados para árvores