1

Contedo

Relatrio 3 rvores Binrias de Pesquisa ....................................................................................... 2
Cdigo Fonte: rvore Binria de Pesquisa .................................................................................... 2
Imagens e Resultados Obtidos: ...................................................................................................... 8
Relatrio 4: rvores AVL e Tabelas Hash. ....................................................................................... 9
Cdigo Fonte: rvore AVL. .......................................................................................................... 9
Imagens e Resultados Obtidos: ................................................................................................ 22
Cdigo Fonte: Tabela Hash. ......................................................................................................... 24
Imagens e Resultados Obtidos: ................................................................................................ 28
Concluso: ................................................................................................................................ 28


2

Relatrio 3 rvores Binrias de Pesquisa

Cdigo Fonte: rvore Binria de Pesquisa

#include <stdio.h>
#include <stdlib.h>


// Estrutura do N, onde foi utilizado recursividade para os ponteiros da subarvore
esquerda e direita.
typedef struct No{
char rua[30];
char residencia[30];
int medidor;
struct No *esquerda;
struct No *direita;
}No;

// Funo iniciarArvore que inicializa a arvore binaria com o valor vazio.
void iniciarArvore(No **Raiz){
*Raiz = NULL;
}

/* Funo inserir, onde os valores serao salvos no N da arvore,
caso seja o primeiro elemento ser salvo como a raiz da arvore.
caso contrario ser salvo de acordo com a sua devida posio.
*/
void inserir(No **pRaiz, char r[30], int med, char res[30]){
if(*pRaiz == NULL){
*pRaiz = (No *) malloc(sizeof(No));
(*pRaiz)->esquerda = NULL;
(*pRaiz)->direita = NULL;
strcpy((*pRaiz)->rua, r);
strcpy((*pRaiz)->residencia, res);
(*pRaiz)->medidor = med;
3

}else{
if(med < (*pRaiz)->medidor)
inserir(&(*pRaiz)->esquerda, r, med, res);
if(med > (*pRaiz)->medidor)
inserir(&(*pRaiz)->direita, r, med, res);
}
}

// Funo remover, onde ser eliminado um unico n por vez na arvore
// e os elementos da sua subarvore esquerda e direita so realocados
No *remover(No *r, int v)
{
if (r == NULL)
return NULL;
else if (r->medidor > v)
r->esquerda = remover(r->esquerda, v);
else if (r->medidor < v)
r->direita = remover(r->direita, v);
else {
if (r->esquerda == NULL && r->direita == NULL) {
free (r);
r = NULL;
}
else if (r->esquerda == NULL) {
No* t = r;
r = r->direita;
free (t);
}}}


// Exibio dos valores seguindo a seguinte ordem:
// Subarvore Esquerda - Raiz - Subarvore Direita
void EmOrdem(No *pRaiz){
if(pRaiz != NULL){
EmOrdem(pRaiz->esquerda);
4

printf("---------------------------\n");
printf("Medidor.....:%d\n", pRaiz->medidor);
printf("Rua.........:%s\n", pRaiz->rua);
printf("Residencia..:%s\n", pRaiz->residencia);
printf("---------------------------\n");
EmOrdem(pRaiz->direita);
}
}

// Exibio dos valores seguindo a seguinte ordem:
// Raiz - Subarvore Esquerda - Subarvore Direita
void PreOrdem(No *pRaiz){
if(pRaiz != NULL){
printf("---------------------------\n");
printf("Medidor.....:%d\n", pRaiz->medidor);
printf("Rua.........:%s\n", pRaiz->rua);
printf("Residencia..:%s\n", pRaiz->residencia);
printf("---------------------------\n");
PreOrdem(pRaiz->esquerda);
PreOrdem(pRaiz->direita);
}
}

// Exibio dos valores seguindo a seguinte ordem:
// Subarvore Esquerda - Subarvore Direita - Raiz
void PosOrdem(No *pRaiz){
if(pRaiz != NULL){
PosOrdem(pRaiz->esquerda);
PosOrdem(pRaiz->direita);
printf("---------------------------\n");
printf("Medidor.....:%d\n", pRaiz->medidor);
printf("Rua.........:%s\n", pRaiz->rua);
printf("Residencia..:%s\n", pRaiz->residencia);
printf("---------------------------\n");
}
5

}

// Busca do medidor recebido como parametro em toda a arvore
No *arvorebusca(No *pRaiz,int med){
while (pRaiz != NULL && pRaiz->medidor != med) {
if (pRaiz->medidor > med)
pRaiz = pRaiz->esquerda;
else
pRaiz = pRaiz->direita;
}
return pRaiz;
}

int main(int argc, char *argv[])
{
char rua[30],res[30];
int op, med, es, busca;
No *arvore;
No *aux;
iniciarArvore(&arvore);
while (op!=5){
printf("---------------------------\n");
printf("| BEM VINDO AO CADASTRO |\n");
printf("| DE RESIDENCIAS |\n");
printf("---------------------------\n");
printf("---------------------------\n");
printf("MENU PRINCIPAL \n");
printf("1- Inserir um novo cadastro\n");
printf("2- Consultar os cadastros \n");
printf("3- Buscar nos cadastros \n");
printf("4- Remover um cadastro \n");
printf("5- Sair \n");
printf("---------------------------\n");
scanf("%d",&op);
switch(op){
6

case 1:
printf("Digite a rua da residencia: \n");
scanf("%s",&rua);
printf("Digite o numero da residencia: \n");
scanf("%s",&res);
printf("Digite o medidor de consumo: \n");
scanf("%d",&med);
inserir(&arvore, rua, med, res);
break;
case 2:
printf("Escolha a forma de exibio: \n");
printf("1 - Pre-Ordem \n");
printf("2 - Em Ordem \n");
printf("3 - Pos Ordem \n");
scanf("%d",&es);
switch (es){
case 1:
PreOrdem(arvore);
break;
case 2:
EmOrdem(arvore);
break;
case 3:
PosOrdem(arvore);
break;
}
break;
case 3:
printf("Qual valor do medidor de consumo deseja pesquisar? \n");
scanf("%d",&busca);
aux= arvorebusca(arvore, busca);
if(aux->medidor == busca){
printf("O valor foi encontrado \n");
printf("---------------------------\n");
printf("Medidor.....:%d\n", aux->medidor);
7

printf("Rua.........:%s\n", aux->rua);
printf("Residencia..:%s\n", aux->residencia);
printf("---------------------------\n");
}
else
printf("Valor nao encontrado \n");
break;
case 4:
printf("Qual valor do medidor de consumo deseja remover? \n");
scanf("%d",&busca);
remover(arvore,busca);
break;
}
}
system("PAUSE");
return 0;
}


















8

Imagens e Resultados Obtidos:


Imagem 1: Inserir um novo cadastro, ou seja, insero de um novo n na rvore.

Imagem 2: Exibio da rvore em Pre-Ordem.

Imagem 3: Busca de um medidor de consumo.
9


Relatrio 4: rvores AVL e Tabelas Hash.

Cdigo Fonte: rvore AVL.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Estrutura do N, onde foi utilizado recursividade para os ponteiros da subarvore
esquerda e direita.
// foi inserido a variavel fatbal que corresponde ao fator de balanceamento de cada n.
typedef struct nodo {
char rua[30];
char residencia[30];
int medidor;
int fatbal;
struct nodo *esq, *dir;
} arvoreAVL;

// Variavel gloval cont corresponde quantidade de ordenaes realizadas.
// Variavel gloval busAVL corresponde quantidade de buscas realizadas
int cont=0, busAVL=0;

// Exibio dos valores seguindo a seguinte ordem:
// Subarvore Esquerda - Raiz - Subarvore Direita
void EmOrdem(arvoreAVL *pRaiz){
if(pRaiz != NULL){
EmOrdem(pRaiz->esq);
printf("---------------------------\n");
printf("Medidor.....:%d\n", pRaiz->medidor);
printf("Rua.........:%s\n", pRaiz->rua);
printf("Residencia..:%s\n", pRaiz->residencia);
printf("---------------------------\n");
10

EmOrdem(pRaiz->dir);
}
}

// Exibio dos valores seguindo a seguinte ordem:
// Raiz - Subarvore Esquerda - Subarvore Direita
void PreOrdem(arvoreAVL *pRaiz){
if(pRaiz != NULL){
printf("---------------------------\n");
printf("Medidor.....:%d\n", pRaiz->medidor);
printf("Rua.........:%s\n", pRaiz->rua);
printf("Residencia..:%s\n", pRaiz->residencia);
printf("---------------------------\n");
PreOrdem(pRaiz->esq);
PreOrdem(pRaiz->dir);
}
}

// Exibio dos valores seguindo a seguinte ordem:
// Subarvore Esquerda - Subarvore Direita - Raiz
void PosOrdem(arvoreAVL *pRaiz){
if(pRaiz != NULL){
PosOrdem(pRaiz->esq);
PosOrdem(pRaiz->dir);
printf("---------------------------\n");
printf("Medidor.....:%d\n", pRaiz->medidor);
printf("Rua.........:%s\n", pRaiz->rua);
printf("Residencia..:%s\n", pRaiz->residencia);
printf("---------------------------\n");
}
}

// Funo inicializaAVL realiza a alocao dinamica da arvore e inicializa os ponteiros das
subarvores como NULL.

11

void InicializaAVL (arvoreAVL **eainicio){
*eainicio = malloc (sizeof (arvoreAVL));
(*eainicio)->esq = NULL;
(*eainicio)->dir = NULL;
}

/* Funo inserir, onde os valores serao salvos no N da arvore,
caso seja o primeiro elemento ser salvo como a raiz da arvore.
caso contrario ser salvo de acordo com a sua devida posio. A cada insero
a rvore balanceada novamente.
*/
void InsereAVL (arvoreAVL *adesc, char r[30], int med, char res[30]) {
arvoreAVL *paux, *pant, *pP, *pQ, *pantP, *pnovo;
int poschave;
int achou;

// Subrotina de Rotao Simples, caso o fator de balanceamento do n seja
// positivo realizar a Rotao Simples a Esquerda, caso seja negativo
// realizar Rotao Simples a Direita
void RotacaoSimples (){
cont++;
if (pP->fatbal == 1) {
pP->dir = pQ->esq;
pQ->esq = pP;
}
else {
pP->esq = pQ->dir;
pQ->dir = pP;
}
paux = pQ;
pP->fatbal = 0;
pQ->fatbal = 0;
}

// Subrotina de Rotao Dupla, caso o fator de balanceamento do n seja
12

// positivo realizar a Rotao Dupla a Esquerda, caso seja negativo
// realizar Rotao Dupla a Direita
void RotacaoDupla (){
cont++;
if (pP->fatbal == 1) {
paux = pQ->esq;
pQ->esq = paux->dir;
paux->dir = pQ;
pP->dir = paux->esq;
paux->esq = pP;
}
else {
paux = pQ->dir;
pQ->dir = paux->esq;
paux->esq = pQ;
pP->esq = paux->dir;
paux->dir = pP;
}
if (paux->fatbal == -poschave){
pP->fatbal = 0;
pQ->fatbal = poschave;
}
else
if (paux->fatbal == 0) {
pP->fatbal = 0;
pQ->fatbal = 0;
}
else {
pP->fatbal = -poschave;
pQ->fatbal = 0;
}
paux->fatbal = 0;
}

//AjustaFatoresAVL funo responsavel pela verificao e alteracao
13

//dos valores do fator de balanceamento de cada n
void AjustaFatoresAVL (){
if (med < pP->medidor){
pQ = pP->esq;
paux = pP->esq;
}
else {
pQ = pP->dir;
paux = pP->dir;
}
while (paux->medidor != med)
if (med < paux->medidor) {
paux->fatbal = paux->fatbal - 1;
paux = paux->esq;
}
else {
paux->fatbal = paux->fatbal + 1;
paux = paux->dir;
}
}

//Funo BalanceiaAVL realiza a checagem dos fatores de balanceamento
//chamando a funo correspondente de acordo com o resultado obtido
void BalanceiaAVL (){
if (med < pP->medidor)
poschave = -1;
else
poschave = 1;
if (pP->fatbal == 0)
pP->fatbal = poschave;
else
if (pP->fatbal == -poschave)
pP->fatbal = 0;
else {
if (pQ->fatbal * poschave > 0)
14

RotacaoSimples ();
else
RotacaoDupla ();
if (pantP->dir == pP)
pantP->dir = paux;
else
pantP->esq = paux;
}
}

paux = adesc->dir;
pP = paux;
pant = adesc;
pantP = adesc;
achou = 0;
while ((!achou) && (paux != NULL)) {
if (paux->fatbal != 0) {
pP = paux;
pantP = pant;
}
pant = paux;
if (med == paux->medidor)
achou = 1;
else
if (med < paux->medidor)
paux = paux->esq;
else
paux = paux->dir;
}
if (achou)
printf("Esta informacao j esta registrada na arvore\n");
else {
pnovo = malloc (sizeof (arvoreAVL));
pnovo->medidor= med;
strcpy(pnovo->rua, r);
15

strcpy(pnovo->residencia, res);
pnovo->esq = NULL;
pnovo->dir = NULL;
pnovo->fatbal = 0;
if (adesc->dir == NULL)
adesc->dir = pnovo;
else {
if (med < pant->medidor)
pant->esq = pnovo;
else
pant->dir = pnovo;
AjustaFatoresAVL ();
BalanceiaAVL ();
}
}
}


// Funo remover, onde ser eliminado um unico n por vez na arvore
// e os elementos da sua subarvore esquerda e direita so realocados e rebalanceados.
arvoreAVL remover(arvoreAVL *r, int med)
{
arvoreAVL *paux, *pant, *pP, *pQ, *pantP, *pnovo;
int poschave;
// Subrotina de Rotao Simples, caso o fator de balanceamento do n seja
// positivo realizar a Rotao Simples a Esquerda, caso seja negativo
// realizar Rotao Simples a Direita
void RotacaoSimples (){
if (pP->fatbal == 1) {
pP->dir = pQ->esq;
pQ->esq = pP;
}
else {
pP->esq = pQ->dir;
pQ->dir = pP;
16

}
// Subrotina de Rotao Dupla, caso o fator de balanceamento do n seja
// positivo realizar a Rotao Dupla a Esquerda, caso seja negativo
// realizar Rotao Dupla a Direita
void RotacaoDupla (){
if (pP->fatbal == 1) {
paux = pQ->esq;
pQ->esq = paux->dir;
paux->dir = pQ;
pP->dir = paux->esq;
paux->esq = pP;
}
else {
paux = pQ->dir;
pQ->dir = paux->esq;
paux->esq = pQ;
pP->esq = paux->dir;
paux->dir = pP;
}
if (paux->fatbal == -poschave){
pP->fatbal = 0;
pQ->fatbal = poschave;
}
else
if (paux->fatbal == 0) {
pP->fatbal = 0;
pQ->fatbal = 0;
}
else {
pP->fatbal = -poschave;
pQ->fatbal = 0;
}
paux->fatbal = 0;
}
//AjustaFatores funo responsavel pela verificao e alteracao
17

//dos valores do fator de balanceamento de cada n
void AjustaFatores (){
if (med < pP->medidor){
pQ = pP->esq;
paux = pP->esq;
}
else {
pQ = pP->dir;
paux = pP->dir;
}
while (paux->medidor != med)
if (med < paux->medidor) {
paux->fatbal = paux->fatbal - 1;
paux = paux->esq;
}
else {
paux->fatbal = paux->fatbal + 1;
paux = paux->dir;
}
}

//Funo Balanceia realiza a checagem dos fatores de balanceamento
//chamando a funo correspondente de acordo com o resultado obtido
void Balanceia (){
if (med < pP->medidor)
poschave = -1;
else
poschave = 1;
if (pP->fatbal == 0)
pP->fatbal = poschave;
else
if (pP->fatbal == -poschave)
pP->fatbal = 0;
else {
if (pQ->fatbal * poschave > 0)
18

RotacaoSimples ();
else
RotacaoDupla ();
if (pantP->dir == pP)
pantP->dir = paux;
else
pantP->esq = paux;
}
}
paux = pQ;
pP->fatbal = 0;
pQ->fatbal = 0;
}


if (r == NULL)
return NULL;
else if (r->medidor > med)
r->esq = remover(r->esq, med);
else if (r->medidor < med)
r->dir = remover(r->dir, med);
else {
if (r->esq == NULL && r->dir == NULL) {
free (r);
r = NULL;
}
else if (r->esq == NULL) {
arvoreAVL* t = r;
r = r->dir;
free (t);

}
AjustaFatores ();
Balanceia ();
}
19


}

main ()
{
arvoreAVL *arAvl;
char rua[30],res[30];
int op, med, es, busca;

InicializaAVL (&arAvl);
fflush(stdin);
while (op!=5){
printf("---------------------------\n");
printf("| BEM VINDO AO CADASTRO |\n");
printf("| DE RESIDENCIAS |\n");
printf("---------------------------\n");
printf("---------------------------\n");
printf("MENU PRINCIPAL \n");
printf("1- Inserir um novo cadastro\n");
printf("2- Consultar os cadastros \n");
printf("3- Buscar nos cadastros \n");
printf("4- Remover um cadastro \n");
printf("5- Sair \n");
printf("---------------------------\n");
scanf("%d",&op);
switch(op){
case 1:
printf("Digite a rua da residencia: \n");
scanf("%s",&rua);
printf("Digite o numero da residencia: \n");
scanf("%s",&res);
printf("Digite o medidor de consumo: \n");
scanf("%d",&med);
InsereAVL(arAvl, rua, med, res);
break;
20

case 2:
printf("Escolha a forma de exibio: \n");
printf("1 - Pre-Ordem \n");
printf("2 - Em Ordem \n");
printf("3 - Pos Ordem \n");
scanf("%d",&es);
switch (es){
case 1:
PreOrdem(arAvl);
break;
case 2:
EmOrdem(arAvl);
break;
case 3:
PosOrdem(arAvl);
break;
}
printf("Numero total de ordenacoes: %d\n", cont);
break;
case 3:
printf("Qual valor do medidor de consumo deseja pesquisar? \n");
scanf("%d",&busca);
aux= arvorebusca(arAvl, busca);
if(aux->medidor == busca){
printf("O valor foi encontrado \n");
printf("---------------------------\n");
printf("Medidor.....:%d\n", arAvl->medidor);
printf("Rua.........:%s\n", arAvl->rua);
printf("Residencia..:%s\n", arAvl->residencia);
printf("---------------------------\n");
}
else
printf("Valor nao encontrado \n");
break;
case 4:
21

printf("Qual valor do medidor de consumo deseja remover? \n");
scanf("%d",&busca);
remover(arAvl,busca);*/
break;
}
}
printf("\nOrdenacao: %d\n",cont);
printf("\nBuscas: %d\n",busAVL);
printf("\n\n");
system("pause");
}


22

Imagens e Resultados Obtidos:


Imagem 4: Insero de um novo n na rvore.

Imagem 5: Exibio dos ns da rvore em Pre-Ordem.
23


Imagem 6: Resultados obtidos aps o encerramento do programa, exibindo as ordenaes e
buscas obtidas aps a insero de 3 ns na rvore.
24

Cdigo Fonte: Tabela Hash.

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

// Variavel global colisao responsavel pela contagem de colises durante
// a execuo do programa
int colisao=0;

// Estrutura de lista encadeada onde a chave corresponde ao medidor de consumo.
struct lista_no {
int chave;
struct lista_no *prox;
};
typedef struct lista_no LISTA;

/* Funo insere realiza a insero de um novo n na lista
apontado para o n anterior, realizando a verificao de coliso
e alocando dinamicamente a lista
para posteriormente realizar a insero.
*/
LISTA* insere(LISTA * a, int med, char op)
{
LISTA *ant = NULL;
LISTA *p = a;

while (p != NULL)
{
if (p->chave == med)
{
printf("\nATENCAO: O registro %d j existe",med);
colisao++;
break;
}
25

ant = p;
p = p->prox;
}

if (p == NULL)
{

p = (LISTA *)malloc(sizeof(LISTA));
p->chave = med;
p->prox = NULL;

if (ant == NULL)
{a = p;
return a;}
else
if(op == 'i')
{a = p;
a->prox = ant;
return a; }
else
{ant->prox = p;
return ant;}
}
}

// Funo Hash responsavel pela gerao da chave de pesquisa
int hash(int med, int n)
{
return (med%n);
}

// Funo recursiva para exibiao de todos os elementos da lista.
void exibir(LISTA *a)
{ LISTA *p = a;
if (p != NULL){
26

printf("-------------------------------\n");
printf("\t Consumo de Energia: %d\n",p->chave);
exibir(p=p->prox); }
}
//Inicializacao da lista.
LISTA *iniciar()
{ return NULL;
}


main(void)
{
int med, n, x, cont, i =0;
char op='i';
LISTA *p;
printf("-------------------------------\n");
printf("| BEM VINDO AO CADASTRO |\n");
printf("| DE RESIDENCIAS |\n");
printf("-------------------------------\n");
printf("Informe a qtd de residencias\nque serao cadastradas: \n");
printf("-------------------------------\n");
scanf("%d",&n);
LISTA *tab[n];
for (i = 0; i < n; i++)
tab[i] = iniciar();
for(cont=0;cont<n;cont++)
{ printf("-------------------------------\n");
printf("Informe o consumo de energia \n");
printf("-------------------------------\n");

scanf("%d",&med);
tab[hash(med,n)] = insere(tab[hash(med,n)],med,op);
}
for(x=0;x<n;x++){
printf("\nPosicao[%d] : COD:%p\n",x,tab[x]);
27

exibir(tab[x]); }

getch();
return (0);
}


28

Imagens e Resultados Obtidos:


Imagem 7: Insero de novos n na lista e exibio dos valores, compostos por:
Posio do n na lista, a chave gerada pela tabela hash de 3 elementos e o respectivo valor
de consumo de energia.

Concluso:

Tabela Hash ou tabela de disperso a ferramenta de busca eficiente, pois utiliza de
elementos ordenados organizados atravs de chaves gerados a partir da prpria funo. Por
esse motivo, uma das principais vantagens desse mtodo a reduo na demanda de
esforo computacional e possui alta eficincia no custo de pesquisa no caso mdio. Porm
por utilizar uma estrutura de dados semelhante ao dicionrio acarreta duas principais
limitaes que so: a impossibilidade de armazenar elementos repetidos e a subutilizao
dos espaos nas tabelas, o que gera uma incerteza quanto ao balanceamento da lista.