1) Descreva os seguintes conceitos: - altura de rvore binria; A altura de um n em uma rvore binria a distncia entre x e o seu descendente mais

s afastado. Ou seja, a altura de x o nmero de passos do mais longo caminho que leva de x at uma folha. A altura de uma rvore a altura da raiz da rvore. Uma rvore com um nico n tem altura 0. - nvel de rvore binria;

- n filho / n pai: o filho apontado pelo seu pai, ento um n que tem outro n em seu link direito/esquerdo pai do n que est no seu link direito/esquerdo e esse n por sua vez filho do dono do link que est apontando para ele; - folha de uma rvore: um n folha um n sem filhos (seus links so nulos); - n interno de uma rvore: um n que tem pelo menos um filho; - nvel de um n: distncia dele at a raiz (a raiz est no nvel 0), a cada link a distncia aumentada em 1 unidade.

- processo de incluso de ns na rvore binria; feita uma busca para verificar se ja existe um n, caso no exista, uma posio indicada para que ele seja inserido. - processo de excluso de ns na rvore binria; O valor do n excluido substituido pelo valor do novo n - rvore AVL;

Uma rvore AVL uma rvore binria de busca construda para que a altura de sua subrvore direita seja diferente da altura da subrvore esquerda de no mximo 1.

- fator de balanceamento.

a altura da subrvore direita do n menos a altura da subrvore esquerda do n

2) Escreva um programa que contenha as seguintes funes relacionadas rvores Binrias: - percurso de rvore binria em ordem;
void em_ordem ( tipoNo *pt) { if (pt) { em_ordem (pt->esq); visita (pt); em_ordem (pt->di

- percurso de rvore binria em pr-ordem;

void pre_ordem ( tipoNo *pt) { if (pt) { visita (pt); pre_ordem (pt->esq); pre_ordem (pt->dir); } }

- percurso de rvore binria em ps-ordem;

void visita (tNo *p) { int alt1, alt2; if (p->esq) alt1 = p->esq->altura; else alt1 = 0; if (p->dir) alt2 = p->dir->altura; else alt2 = 0; if (alt1>alt2) p->altura = alt1 + 1; else p->altura = alt2 + 1; printf("info = %d ", p->info); printf("altura = %d\n", p->altura); }

- incluso de um novo n na rvore binria;

#include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct stNo { int info;

struct stNo *esq, *dir; } tNo ; tNo *cria_arvore( int ); tNo *cria_no( ); void pos_esq (tNo *, int ); void pos_dir (tNo *, int ); void main() { tNo *raiz, *p, *q; char linha[80], *numero; int num; gets(linha); numero = strtok(linha, " "); /* pega o primeiro numero da lista */ num = atoi(numero); raiz = cria_arvore(num); /* insere na raiz */ numero = strtok(NULL, " "); while (numero) { q = raiz; p = raiz; printf("Li numero %d\n", num); /* le novo numero */ num = atoi(numero); while (num != p->info && q) { /* procura na arvore */ p = q; if (num < p->info) q = p->esq; /* passa para arvore esquerda */ else q = p->dir; /* passa para direita */ } if (num == p->info) printf("O numero %d ja existe na arvore.\n", num); else { /* vou inserir o numero na arvore */ if (num < p->info) pos_esq(p, num); else pos_dir(p, num); } numero = strtok(NULL, " "); } /* fim do while (numero) */

tNo *cria_arvore (int x) { tNo *p; p = cria_no (); if (p) { p->info = x; return p; } else { puts("Faltou espaco para alocar no."); exit(1); }

tNo *cria_no() { tNo *p; if ((p = (tNo *) malloc(sizeof(tNo))) == NULL) return NULL;

else { p->esq = NULL; p->dir = NULL; return p; }

void pos_esq(tNo *p, int x) { tNo *q; if (p->esq) puts("Operacao de insercao a esquerda ilegal."); else { q = cria_arvore(x); p->esq = q; } }

void pos_dir(tNo *p, int x) { tNo *q; if (p->dir) puts("Operacao de insercao a direita ilegal."); else { q = cria_arvore(x); p->dir = q; }

- excluso de um n da rvore binria;

tNo *remover (tNo *tree, int num) { tNo *p, /* p aponta para o no a ser removido */ *q, /* q aponta para o pai do no */ *rp, /* rp aponta que ira substituir o no p */ *f, *s; /* sucessor do no p */ p = tree; q=NULL; /* procura o no com a chave num, p aponta para o no e q aponta para o pai do no */ while ( p && p->info != num) { q = p; if ( num < p->info) p = p->esq; else p = p->dir; } /* fim do while */ if (!p) return NULL; /* a chave nao existe na arvore */ /* agora iremos ver os dois primeiros casos, o no tem um filho no maximo */ if (p->esq == NULL) rp = p->dir; else

if (p->dir == NULL) rp = p->esq; else { f=p; rp = p->dir; s = rp->esq; /* s e sempre o filho esq de rp */ while (s != NULL) { f = rp; rp = s; s = rp->esq; } /* neste ponto, rp e o sucessor em ordem de p */ if (f != p) { /* p nao e o pai de rp e rp == f->left */ f->esq = rp->dir; /* remove o no rp de sua atual posicao e o substitui pelo filho direito de rp rp ocupa o lugar de p */ rp->dir = p->dir; } /* define o filho esquerdo de rp de modo que rp ocupe o lugar de p */ rp->esq = p->esq; } /* insere rp na posicao ocupada anteriormente por p */ if (q == NULL) tree = rp; else if (p == q->esq) q->esq = rp; else q->dir = rp; free(p); return rp;

- consultar um n na rvore binria.

f arvore_binaria_buscar(no, valor): if no is None: # valor no encontrado return None else: if valor == no.valor: # valor encontrado return no.valor elif valor < no.valor: # busca na subrvore esquerda return arvore_binaria_buscar(no.filho_esquerdo, valor) elif valor > no.valor: # busca na subrvore direita return arvore_binaria_buscar(no.filho_direito, valor)