void atualizarAltura(NoAVL<T>* arv) {
int m,n,d;
m = altura(arv->getEsquerda());
n = altura(arv->getDireita());
d = maX(m,n);
arv->height = d + 1;
}
int main(){
int i;
Dicbin a=vacio();
do{
scanf("%d",&i);
if(i==0){break;}
a=insord(i,a);
puts("....");
inorder(a);
printf("\n\nLa altura del arbol es: %d", altura(a));
printf("\n\nEl factor de balanceo del arbol es: %d" , factbal(a));
if(esavl(a)){
printf("\n\nEl arbol es AVL");
}
else{
printf("\n\nEl arbol NO es AVL");
printf("\n\nRotando el arbol....");
a=hazavl(a);
printf("\n\nLa altura del arbol es: %d", altura(a));
printf("\n\nEl factor de balanceo del arbol es: %d" , factbal(a));
}
}while(i);
puts("**********");
a=hazavl(a);
printf("\n\nLa altura del arbol final es: %d", altura(a));
printf("\n\nEl factor de balanceo del arbol es: %d" , factbal(a));
return 0;
}
//------------------------------------------------------------------------------
// ALTURA
// Retorna a altura de um nó
//------------------------------------------------------------------------------
int altura(Registro *reg) {
if (reg == NULL) return 0;
int esq = altura(reg->esq);
int dir = altura(reg->dir);
return (esq >= dir)? esq + 1 : dir + 1;
}
int fatorBalanceamento(struct No *raiz)
{
if(raiz!=NULL)
{
return altura(raiz->esquerda) - altura(raiz->direita);
}
return 0;
}
Nodo* Nodo::rotacaoEsquerdaSimples(Nodo* k2) {
Nodo* k1;
k1 = k2->esquerda;
k2->esquerda = k1->direita;
k1->direita = k2;
/* atualizando alturas */
k2->alt = max(altura(k2->esquerda), altura(k2->direita)) + 1;
k1->alt = max(altura(k1->esquerda), k2->alt) + 1;
return k1; /* nova raiz da subárvore */
}
// ------------------------------------------------------------------------------
// Funcao fator de balanceamento
// ------------------------------------------------------------------------------
int fat_bal(nodo * raiz)
{
if (raiz == NULL){
return 0;
} else {
return (altura(raiz->dir) - altura(raiz->esq));
}
}
int altura (arvore *raiz){
int alt_dir, alt_esq;
if (raiz == NULL)
return -1;
else{
alt_dir = altura (raiz->dir);
alt_esq = altura (raiz->esq);
return((alt_dir > alt_esq) ? (1 + alt_dir) : (1 + alt_esq));
}
}
int altura (arvore r) {
if (r == NULL)
return -1;
else {
int he = altura (r->esq);
int hd = altura (r->dir);
if (he < hd) return hd + 1;
else return he + 1;
}
}
int fatorB(Tree * arvore) {
int hesq=0, hdir=0;
if(arvore->esq!=NULL) hesq=1+altura(arvore->esq);
if(arvore->dir!=NULL) hdir=1+altura(arvore->dir);
return hesq-hdir;
}
Tree * balanceiaArvore(Tree * arvore){
int hesq=0, hdir=0,FB=0,he=0,hd=0;
if(arvore==NULL) return NULL;
if((arvore->esq==NULL) && (arvore->dir==NULL)) return arvore;
arvore->esq=balanceiaArvore(arvore->esq);
arvore->dir=balanceiaArvore(arvore->dir);
while(fatorB(arvore)<-1){
he=0,hd=0;
if(arvore->dir->esq != NULL) he=1+altura(arvore->dir->esq);
if(arvore->dir->dir != NULL) hd=1+altura(arvore->dir->dir);
if(he > hd) arvore=rotacao_RL(arvore);
arvore=rotacao_RR(arvore);
}
while(fatorB(arvore)>1){
he=0,hd=0;
if(arvore->esq->esq != NULL) he=1+altura(arvore->esq->esq);
if(arvore->esq->dir != NULL) hd=1+altura(arvore->esq->dir);
if(he < hd) arvore=rotacao_LR(arvore);
arvore=rotacao_LL(arvore);
}
/*if(hesq > hdir){
if(arvore->esq->esq != NULL) he=1+altura(arvore->esq->esq);
if(arvore->esq->dir != NULL) hd=1+altura(arvore->esq->dir);
if(he < hd) rotacao_LR(arvore->esq->dir);
rotacao_LL(arvore->esqrn arvore);
}
if(hdir>hesq){
if(arvore->dir->esq != NULL) he=1+altura(arvore->dir->esq);
if(arvore->dir->dir != NULL) hd=1+altura(arvore->dir->dir);
if(hd < he) rotacao_RL(arvore->dir->esq);
rotacao_RR(arvore);
}*/
return arvore;
}
no* rotParaEsquerda(no* x){
no *y;
y = x->direito;
x->direito = y->esquerdo;
y->esquerdo = x;
x->altura = altura(x);
y->altura = altura(y);
return(y);
}
NoAVL<T>* simp_roda_dir(NoAVL<T>* k2) {
NoAVL<T>* k1;
k1 = k2->getDireita();
k2->direita = k1->getEsquerda();
k1->esquerda = k2;
k2->height = maX(altura(k2->getDireita()), altura(k2->getEsquerda()))+1;
k1->height = maX(altura(k1->getDireita()), k2->height)+1;
return k1;
}
int altura(AB t)
{ int hi,hd;
if(t == NULL)
return -1;
else
{
hi=altura(t->izq);
hd=altura(t->der);
if(hi > hd)
return (1 + hi);
else
return (1 + hd);
}
}
int avl(AB t)
{ int hi,hd;
if(t == NULL)
return 1;
else
{
hi=altura(t->izq);
hd=altura(t->der);
if(abs(hi - hd) <= 1)
return avl(t->izq) && avl(t->der);
else
return 0;
}
}
int altura(ptno *tree){
int altesq, altdir;
if(tree!=NULL){
if(tree->esq==NULL && tree->dir==NULL)
return 0;
altesq=altura(tree->esq);
altdir=altura(tree->dir);
if(altesq>altdir)
return altesq+1;
else
return altdir+1;
}
return 0;
}
int
altura(arbol_t *arbol)
{
if(arbol != NULL) {
int izq = altura(arbol->izq);
int der = altura(arbol->der);
if(der < izq) {
return izq + 1;
} else {
return der + 1;
}
} else {
return -1;
}
}
int Arvore::altura(No* pNo)
{
if(pNo)
{
int alturaesquerda = altura(pNo->getEsquerda()) ;
int alturadireita = altura(pNo->getDireita());
pNo->setAltura(max(alturaesquerda,alturadireita)+ 1);
pNo->setPeso(alturadireita - alturaesquerda);
return pNo->getAltura();
}
else
{
return 0;
}
}
NoABP *verifica_balanceamento(NoABP *n){
if(n != NULL){
NoABP *p = verifica_balanceamento(n->esq);
if(p != NULL)
return p;
p = verifica_balanceamento(n->dir);
if(p != NULL)
return p;
n->fb = altura(n->esq) - altura(n->dir);
if(n->fb == 2 || n->fb == -2)
return n;
}
return NULL;
}
int main()
{
struct Arvore *t = criaArvore();
int num;
char c[5];
gets(c);
while(scanf("%d", &num) != EOF)
inserir(t, criaNo(&num));
if(strcmp(c, "POS") == 0)
posOrdem(t->raiz);
else if(strcmp(c, "PRE") == 0)
preOrdem(t->raiz);
else
inOrdem(t->raiz);
printf("%d", altura(t->raiz));
printf(" %d", rotacao);
}
void printar_largura(arvore* raiz){
if (raiz)
for (int i=1; i<=(altura(raiz)+1); i++){
printar_nivel(raiz, i);
printf("\n");
}
}
no* insercao(no* T, int x){
if(T == NULL){
T=(no*) malloc(sizeof(no));
T->dado = x;
T->esquerdo = NULL;
T->direito = NULL;
}else if(x > T->dado){// Insere na sub arvore correta
T->direito=insercao(T->direito, x);
if(difAlturaEsq_e_Dir(T) == -2){
if(x > T->direito->dado)
T = balanc2Direita(T);
else
T = balancDireitaEsquerda(T);
}
}else if(x<T->dado){
T->esquerdo = insercao(T->esquerdo, x);
if(difAlturaEsq_e_Dir(T) == 2){
if(x < T->esquerdo->dado)
T = balanc2Esquerda(T);
else
T = balancEsquerdaDireita(T);
}
}
T->altura = altura(T);
return(T);
}
int altura(NoABP *n){
if(n == NULL)
return 0;
else{
if(n->esq == NULL && n->dir == NULL)
return 1;
else{
int esq = altura(n->esq);
int dir = altura(n->dir);
if(esq > dir)
return 1 + esq;
else
return 1 + dir;
}
}
}
// ------------------------------------------------------------------------------
// Funcao altura
// ------------------------------------------------------------------------------
int altura (nodo * raiz)
{
int esq, dir;
if (raiz == NULL){
return -1;
} else {
esq = altura(raiz->esq);
dir = altura(raiz->dir);
if ( esq > dir )
return esq + 1;
else
return dir + 1;
}
}
void h(tree * figueira)
{
printf("\n");
printf("4. Altura da arvore\n");
printf("------------------------\n");
printf("Altura: %d", altura(figueira->raiz));
printf("\n");
}
int altura(struct No *raiz)
{
int d=0, e=0;
if (raiz == NULL)
return -1;
else
{
e = altura(raiz->esquerda);
d = altura(raiz->direita);
if (e < d)
return d + 1;
else
return e + 1;
}
}
int main(){
FILE *fp1, *fp2;
arvore *raiz1 = NULL;
arvore *raiz2 = NULL;
info letra;
if(!fopen("texto1.txt","r"))
printf("%s\n", "sem arquivo 1");
else
fp1=fopen("texto1.txt","r");
while (!feof(fp1)){
letra = getc(fp1);
if((letra!='\n') && (letra!=EOF) && (letra!='\r'))
insere_arvore_ordenando(&raiz1,letra);
}
if(!fopen("texto2.txt","r"))
printf("%s\n", "sem arquivo 2");
else
fp2=fopen("texto2.txt","r");
while (!feof(fp2)){
letra = getc(fp2);
if((letra!='\n') && (letra!=EOF) && (letra!='\r'))
insere_arvore_ordenando(&raiz2,letra);
}
printf("Arvore 1: ");
printar_arvore(raiz1);
printf("\nElementos no arvore 1 = %d ",contagem(raiz1));
printf("\nAltura no arvore 1 = %d ",1+altura(raiz1));
printf("\nEstrutura da Arvore 1:\n");
printar_largura(raiz1);
printf("\n\n");
printf("Arvore 2: ");
printar_arvore(raiz2);
printf("\nElementos no arvore 2 = %d\n",contagem(raiz2));
printf("Altura da arvore 2 = %d ",1+altura(raiz2));
printf("\nEstrutura da Arvore 2:\n");
printar_largura(raiz1);
if(!percorrer(raiz1, raiz2))
printf("\n\nArvores iguais.\n");
else
printf("\n\nArvores nao iguais.\n");
return 0;
}
No* Arvore::adicionar(const float cValor, No* pNo)
{
if(cValor < pNo->getValor())
{
if(pNo->getEsquerda())
{
pAux3 = adicionar(cValor, pNo->getEsquerda());
if(pAux3)
{
pNo->setEsquerda(pAux3);
}
altura(pNo);
pAux3 = balancear(pNo);
}
else
{
pNo->setEsquerda(new No(cValor));
return NULL;
}
}
else
{
if(pNo->getDireita())
{
pAux3 = adicionar(cValor, pNo->getDireita());
if(pAux3)
{
pNo->setDireita(pAux3);
}
altura(pNo);
pAux3 = balancear(pNo);
}
else
{
pNo->setDireita(new No(cValor));
return NULL;
}
}
return pAux3;
}
void Arvore::imprimir()
{
altura(raiz);
if(raiz)
{
imprimir(raiz);
}
else
{
cout<<endl<<"Nao existem elementos nessa arvore"<<endl;
}
}
void Arvore::imprimir(No* pNo)
{
if(pNo != NULL)
{
imprimir(pNo->getEsquerda());
cout<<pNo->getValor()<<" - ";
cout<<altura(pNo)<<" ";
cout<<" - "<<pNo->getPeso()<<endl;
imprimir(pNo->getDireita());
}
}
ArvAvl * insere_ArvAVL(ArvAVL * arv, int info ){
if( arv == NULL ){
arv = aloca(info);
}
else if( info < arv->info ){
arv->esq = insere( info, arv->esq );
if( altura( arv->esq ) - altura( arv->dir ) == 2 ){
if( info < arv->esq->info )
arv = rotacaoRR( arv );
else
arv = rotacaoLR( arv );
}
}
else if( info > arv->info ){
arv->dir = insere( info arv >dir);
if( altura( arv->dir ) - altura( arv->esq ) == 2 ){
if( info > arv->dir->info )
arv = rotacaoLL( arv );
else
arv = rotacaoRL( arv );
}
}
arv->altura = maior( altura( arv->esq ), altura( arv->dir ) ) + 1;
return arv;
}
