Árvore Binária de Árvore Binária de BuscaBusca

Estrutura de Dados IIEstrutura de Dados II

Prof. GaleProf. Gale

Árvores ConceitosÁrvores Conceitos

Existem alguns conceitos que são comuns a todos os tipos de árvores. Eis alguns desses conceitos que devemos conhecer:

Nó: item de informação com ramos para outros nós (descendentes).

Grau: número de sub-árvores de um nó. Folhas: nós terminais (grau = 0). Filhos de um nó: raízes das sub-árvores desse nó. Pai: ancestral direto de um nó. Grau de uma árvore: grau máximo dos nós da árvore. Ancestral de um nó: todos os nós a partir da raiz até o pai do

nó. Descendentes de um nó: todos os nós nas sub-árvores de

um nó. Nível de um nó:Raiz tem nível 1. Nó no nível i, seus filhos

estão no nível i+1 Altura/profundidade de uma árvore: nível maior

considerando qualquer nó da árvore.

Árvores bináriasÁrvores binárias

– – árvore binária balanceada:árvore binária balanceada:

• • os nós internos têm todos, os nós internos têm todos, ou quase todos, 2 filhosou quase todos, 2 filhos

• • qualquer nó pode ser qualquer nó pode ser alcançado a partir da raiz em alcançado a partir da raiz em O(log n) O(log n) passospassos

Árvore BináriaÁrvore Binária É um conjunto finito de nós que pode ser vazio ou

consistir de uma raiz e duas árvores binárias disjuntas chamadas sub-árvore esquerda e direita.

Fazendo Relação...Fazendo Relação...“Nó Lista Ligada” X“Nó Lista Ligada” X

X “Nó de uma Árvore Binária”X “Nó de uma Árvore Binária”

Ilustrando, ficaria...Ilustrando, ficaria...

Árvore Binária de BuscaÁrvore Binária de Busca

Árvores binárias de buscaÁrvores binárias de busca

– – o valor associado à raiz é sempre maior que o valor o valor associado à raiz é sempre maior que o valor associado a qualquer nó da sub-árvore à esquerda (associado a qualquer nó da sub-árvore à esquerda (saesae) )

– – o valor associado à raiz é sempre menor ou igual (para o valor associado à raiz é sempre menor ou igual (para permitir repetições) que o valor associado a qualquer nó permitir repetições) que o valor associado a qualquer nó da sub-árvore à direita (da sub-árvore à direita (sadsad))

– – quando a árvore é percorrida em ordem simétrica (quando a árvore é percorrida em ordem simétrica (sae - sae - raiz - sadraiz - sad), os valores são encontrados em ordem não ), os valores são encontrados em ordem não decrescentedecrescente

Inserção de NósInserção de Nós

Outra inserção...Outra inserção...

Nova Inserção...Nova Inserção...

E por fim...E por fim...

Tipo árvore bináriaTipo árvore binária– – árvore é representada pelo ponteiro árvore é representada pelo ponteiro

para o nó raizpara o nó raizstruct arv struct arv {{

int info;int info;struct arv* esq;struct arv* esq;struct arv* dir;struct arv* dir;

};};typedef struct arv Arv;typedef struct arv Arv;

Operação de criação:Operação de criação:

– – árvore vazia representada por NULLárvore vazia representada por NULL

Arv* abb_cria (void)Arv* abb_cria (void)

{{

return NULL;return NULL;

}}

Operação de impressão:Operação de impressão:– – imprime os valores da árvore em ordem imprime os valores da árvore em ordem

crescente, percorrendo os nós em ordem crescente, percorrendo os nós em ordem simétricasimétrica

void abb_imprime (Arv* a)void abb_imprime (Arv* a){{ if (a != NULL) if (a != NULL) {{ abb_imprime(a->esq);abb_imprime(a->esq); printf("%d\n",a->info);printf("%d\n",a->info); abb_imprime(a->dir);abb_imprime(a->dir); }}}}

Pesquisa em árvores binárias de Pesquisa em árvores binárias de buscabusca

– – compare o valor dado com o valor compare o valor dado com o valor associado à raizassociado à raiz

– – se for igual, o valor foi encontradose for igual, o valor foi encontrado

– – se for menor, a busca continua na se for menor, a busca continua na saesae

– – se for maior, a busca continua na se for maior, a busca continua na sadsad

Operação de busca:Operação de busca:– – explora a propriedade de ordenação da árvoreexplora a propriedade de ordenação da árvore

– – possui desempenho computacional proporcional à possui desempenho computacional proporcional à altura (O(log n) para o caso de árvore altura (O(log n) para o caso de árvore balanceada)balanceada)

Arv* abb_busca (Arv* r, int v)Arv* abb_busca (Arv* r, int v)

{{

if (r == NULL) return NULL;if (r == NULL) return NULL;

else if (r->info > v) return abb_busca (r->esq, v);else if (r->info > v) return abb_busca (r->esq, v);

else if (r->info < v) return abb_busca (r->dir, v);else if (r->info < v) return abb_busca (r->dir, v);

else return r;else return r;

}}

Operação de inserção: Operação de inserção: – – recebe um valor v a ser inseridorecebe um valor v a ser inserido– – retorna o eventual novo nó raiz da (sub- árvore)retorna o eventual novo nó raiz da (sub- árvore)– – para adicionar v na posição correta, faça:para adicionar v na posição correta, faça:

se a (sub-)árvore for vaziase a (sub-)árvore for vazia– – crie uma árvore cuja raiz contém vcrie uma árvore cuja raiz contém v

• • se a (sub-)árvore não for vaziase a (sub-)árvore não for vazia– – compare v com o valor na raizcompare v com o valor na raiz– – insira v na sae ou na sad, conforme o resultado insira v na sae ou na sad, conforme o resultado da comparaçãoda comparação

Operação de remoção:Operação de remoção:– – recebe um valor v a ser inseridorecebe um valor v a ser inserido– – retorna a eventual nova raiz da árvoreretorna a eventual nova raiz da árvore– – para remover v, faça:para remover v, faça:

• • se a árvore for vaziase a árvore for vazia– – nada tem que ser feitonada tem que ser feito

• • se a árvore não for vaziase a árvore não for vazia– – compare o valor armazenado no nó raiz com vcompare o valor armazenado no nó raiz com v– – se for maior que v, retire o elemento da sub-se for maior que v, retire o elemento da sub-árvore à esquerdaárvore à esquerda– – se for menor do que v, retire o elemento da sub-se for menor do que v, retire o elemento da sub-árvore à direitaárvore à direita– – se for igual a v, retire a raiz da árvorese for igual a v, retire a raiz da árvore

Operação de remoção (cont.):Operação de remoção (cont.):

– – para retirar a raiz da árvore, há 3 para retirar a raiz da árvore, há 3 casos:casos:

• • caso 1: a raiz que é folhacaso 1: a raiz que é folha

• • caso 2: a raiz a ser retirada possui caso 2: a raiz a ser retirada possui um único filhoum único filho

• • caso 3: a raiz a ser retirada tem dois caso 3: a raiz a ser retirada tem dois filhosfilhos

ExercíciosExercícios1.) Desenvolva um programa em “C” que crie uma árvore e insira dados nesta árvore.

#include <stdio.h>#include <conio.h>#include <stdlib.h>// definindo a estrutura da arvorestruct arv { int info; struct arv* esq; struct arv* dir;};

typedef struct arv Arv;

// Criação da árvore// Criação da árvoreArv* abb_cria (void)Arv* abb_cria (void){{ return NULL;return NULL;}}

// Inserção de um nó// Inserção de um nóArv* abb_insere (Arv* a, int v)Arv* abb_insere (Arv* a, int v){{ if (a==NULL) if (a==NULL) {{ a = (Arv*)malloc(sizeof(Arv));a = (Arv*)malloc(sizeof(Arv)); a->info = v;a->info = v; a->esq = a->dir = NULL;a->esq = a->dir = NULL; }} else else if (v < a->info)if (v < a->info) a->esq = abb_insere(a->esq,v);a->esq = abb_insere(a->esq,v); else /* v > a->info */else /* v > a->info */ a->dir = abb_insere(a->dir,v);a->dir = abb_insere(a->dir,v); return a;return a;}}

int main()int main(){{ Arv* arvore;Arv* arvore; arvore = abb_cria();arvore = abb_cria(); arvore = abb_insere(arvore,5);arvore = abb_insere(arvore,5); arvore = abb_insere(arvore,7);arvore = abb_insere(arvore,7); arvore = abb_insere(arvore,2);arvore = abb_insere(arvore,2); arvore = abb_insere(arvore,11);arvore = abb_insere(arvore,11); arvore = abb_insere(arvore,13);arvore = abb_insere(arvore,13);

getch();getch(); return 0;return 0;}}

E a impressão??? A Visualização dos dados...???

Função de ImpressãoFunção de Impressão

// impressão dos dados da árvore// impressão dos dados da árvorevoid abb_imprime (Arv* a)void abb_imprime (Arv* a){{ if (a != NULL) if (a != NULL) {{ abb_imprime(a->esq);abb_imprime(a->esq); printf("%d\n",a->info);printf("%d\n",a->info); abb_imprime(a->dir);abb_imprime(a->dir); }}}}

Exercícios PropostosExercícios Propostos

Exercicio 1 - Gere uma arvore de 20 Exercicio 1 - Gere uma arvore de 20 nós com valores aleatórios de 0 a nós com valores aleatórios de 0 a 100 e mostre a arvore e os 100 e mostre a arvore e os endereços na telaendereços na tela

Exercícios PropostosExercícios Propostos

Exercicio 2 - Implemente uma função Exercicio 2 - Implemente uma função que retorne a quantidade de folhas que retorne a quantidade de folhas de uma árvore binária. Essa função de uma árvore binária. Essa função deve obedecer ao protótipo:deve obedecer ao protótipo:

// int folhas (Arv* a)// int folhas (Arv* a)

Exercícios PropostosExercícios Propostos

Exercicio 3 - Implemente uma função Exercicio 3 - Implemente uma função que compare se duas árvores que compare se duas árvores binárias são iguais. Essa função deve binárias são iguais. Essa função deve obedecer ao protótipo:obedecer ao protótipo:

// Arv* igual (Arv* a, Arv* b)// Arv* igual (Arv* a, Arv* b)