CENTRO UNIVERSITARIO DE CIENCIAS

EXACTAS E INGENIERAS
El rbol AVL, implementacin dinmica.
Actividad: Actividad 14.
Nombre: Godinez Romero Manuel Alejandro
Matricula: 207038836
Carrera: Ingeniera En Informtica
Materia: Estructura de datos 1
Profesor: Gutirrez Hernndez Alfredo
Turno: Matutino
Das: Martes y Jueves
Horario: 7:00 a.m. a 9:00 a.m.

Problema:
Reutilice el programa resultante de la actividad 13. Agregue
y/o modifique los mtodos necesarios para que el rbol sea
implementado como AVL.
Requerimientos:
a) El estilo de programacin debe ser Orientado a Objetos

Reporte.
Esta actividad comenc tomando como lo requiere la actividad tome la
actividad 13 donde es un rbol binario de bsqueda donde tenia que
imprimir el pre orden , in orden y pos orden y tambin su altura ya
teniendo ese rbol comenc por aadir las rotacin que son simple a la
izquierda simple a la derecha y despus la doble a la izquierda y doble a
la derecha que es donde se afectaran los cambios del rbol para que sea
equilibrado y as el rbol no se carga para ningn lado si no sea
balanceado por que por ejemplo en mi rbol de la actividad 13 un rbol
de 1000 elementos era como de altura 20 eso es demasiado par UN
ARBOL ya cuando tome los mtodos de rotacin tambin ice uno de
balanceo donde resto hijo izquierdo e hijo derecho que es mi factor de
equilibrio despus tengo un factor de balance que en todos estos
mtodos claramente recibo una posicin de tipo nodo el factor de
equilibrio lo ice de tipo short que es un entero muy corto pero tambin
en negativos sea que puede leer valores mas o menos de menos mil a
mil por as decirlo tambin en mi operacin factor de balance verifico el
equilibrio de cada parte del rbol donde e insertado de abajo asa riba
para checar el equilibrio de menos uno cero y uno como el profe nos
enseo yo siento que mi rbol esta muy parecido al de profesor por que
tambin me esforc por usar los mtodos interfaces que son muy
buenos en su totalidad para que el usuario no vea con que se esta
trabajando de tras y no tengan acceso a ellos tambin me hicieron falta
los mtodos para que fuera un rbol hilvanado y sus nodos conocieran
quien es el padre tambin puse que cuando hiciera cada rotacin me
avisara imprimiendo la rotacin que se esta asiendo y ase un salto de
lnea para ver en que numero hiso la rotacin y asa donde fue que la
hiso.

nodoAbl.h

//
// NodoABl.h
// Actividad 13
//
// Created by manuel romero on 21/05/14.
// Copyright (c) 2014 manuel romero. All rights
reserved.
//
#ifndef Actividad_13_NodoABl_h
#define Actividad_13_NodoABl_h
template <class T>
class ablNodo{
private :
T dato;
ablNodo* hijoIzq;
ablNodo* hijoDer;
ablNodo* nodoPadre;
unsigned peso;
public:
ablNodo();
ablNodo(T);
T getDato();
ablNodo<T>*& gethijoIzq();
ablNodo<T>*& gethijoDer();
ablNodo<T>*& getNodoPadre();
unsigned getPeso();
void setDato(T);

void sethijoIzq(ablNodo*&);
void sethijoDer(ablNodo*&);
void setNodoPadre(ablNodo*&);
void setPeso(unsigned);
//void getActuAltu();
void actualizarPeso();
};
template <class T>
ablNodo<T>::ablNodo(){
nodoPadre=hijoIzq=hijoIzq=nullptr;
peso = 1;
}
template <class T>
ablNodo<T>::ablNodo(T e){
dato = e;
nodoPadre=hijoIzq=hijoIzq=nullptr;
peso = 1;
}
template <class T>
T ablNodo<T>::getDato(){
return dato;
}
template <class T>
ablNodo<T>*& ablNodo<T>::gethijoIzq(){
return hijoIzq;
}
template <class T>
ablNodo<T>*& ablNodo<T>::gethijoDer(){
return hijoDer;
}
template <class T>

ablNodo<T>*& ablNodo<T>::getNodoPadre(){
return nodoPadre;
}
template <class T>
unsigned ablNodo<T>::getPeso(){
return peso;
}
template <class T>
void ablNodo<T>::setDato(T e){
dato=e;
}
template <class T>
void ablNodo<T>::sethijoIzq(ablNodo*& pos){
hijoIzq = pos;
}
template <class T>
void ablNodo<T>::sethijoDer(ablNodo*& pos){
hijoDer = pos;
}
template <class T>
void ablNodo<T>::setNodoPadre(ablNodo*& pos){
nodoPadre = pos;
}
template <class T>
void ablNodo<T>::setPeso(unsigned pe){
peso = pe;
}

template <class T>

void ablNodo<T>::actualizarPeso(){
if((hijoIzq == nullptr && hijoDer == nullptr)){

peso = 0;
}
else{
if(hijoIzq == nullptr){
peso = hijoDer->getPeso() + 1;
}
else{
if(hijoDer == nullptr){
peso = hijoIzq->getPeso() + 1;
}
else{
if(hijoIzq->getPeso() > hijoDer>getPeso()){
peso = hijoIzq->getPeso() + 1;
}
else{
peso = hijoDer->getPeso() + 1;
}
}
}
}
}

rbol.h

//
// Arbol.h
// Actividad 13
//
// Created by manuel romero on 23/05/14.
// Copyright (c) 2014 manuel romero. All rights
reserved.
//
#ifndef Actividad_13_Arbol_h
#define Actividad_13_Arbol_h

#include "NodoABl.h"
#include <iostream>
using namespace std;
class AblException:public exception
{
private:
string msg;
public:
virtual const char* what() const throw()
{
return msg.c_str();
}
AblException(string m)
{
msg=m;
};
};
template <class T>
class Arbol{
private:
ablNodo<T>* arbl;
void inserDato(ablNodo<T>*& , T&);
void borrarAbl(ablNodo<T>*&);
//*************************************************
*******************
short getFacEqui(ablNodo<T>*&);
void rotSimplDere(ablNodo<T>*&);

void rotDobleDere(ablNodo<T>*&);
void rotSimplIzqu(ablNodo<T>*&);
void rotDobleIzqu(ablNodo<T>*&);
void eBalance(ablNodo<T>*&);
//*************************************************
********************
void imprPreor(ablNodo<T>*&);
void imprIno(ablNodo<T>*&);
void imprPos(ablNodo<T>*&);
int getAltura(ablNodo<T>*&);
ablNodo<T>*&
ablNodo<T>*&
ablNodo<T>*&
ablNodo<T>*&
ablNodo<T>*&

busDato (ablNodo<T>*& , T&);

getMenor(ablNodo<T>*&);
getMayor(ablNodo<T>*&);
getIzqHijo (ablNodo<T>*&);
getDerHijo (ablNodo<T>*&);

public:
Arbol();
~Arbol();
ablNodo<T>*& getIzque();
ablNodo<T>*& getDerech();
ablNodo<T>*& busDato(T&);
void inicializa();
bool etaVacia();
void inserDato(T&);
void borraPos(ablNodo<T>*&);
void borraDato(T&);
void imprPreor();

void imprIno();
void imprPos();
void borraTodo();
int getAltura();
unsigned getPeso();
};
//*************************************************
********************
//Metodos privados
template <class T>
void Arbol<T>::inserDato(ablNodo<T>*& pos , T& e){
if(pos == nullptr){
pos = new ablNodo<T> (e);
if(!pos){
throw AblException ("Error de
posicion");
}
}else{
if(e < pos->getDato()){
inserDato(pos->gethijoIzq(), e);
}else{
inserDato(pos->gethijoDer(), e);
}
pos->actualizarPeso();
eBalance(pos);
}
}

template <class T>

void Arbol<T>::borrarAbl(ablNodo<T>*& pos){
if(pos == nullptr){
return;
}
borrarAbl(pos->gethijoIzq());
borrarAbl(pos->gethijoDer());
delete pos;
pos = nullptr;
}
template <class T>
void Arbol<T>::imprPreor(ablNodo<T>*& pos){
if(pos == nullptr){
return;
}
cout<< pos->getDato()<<"-";
imprPreor(pos->gethijoIzq());
imprPreor(pos->gethijoDer());
}
template <class T>
void Arbol<T>::imprIno(ablNodo<T>*& pos){
if(pos == nullptr){
return;
}
imprIno(pos->gethijoIzq());
cout<< pos->getDato()<<"-";
imprIno(pos->gethijoDer());
}
template <class T>
void Arbol<T>::imprPos(ablNodo<T>*& pos){
if(pos == nullptr){
return;
}
imprPos(pos->gethijoIzq());
imprPos(pos->gethijoDer());
cout<< pos->getDato()<<"-";
}

template <class T>

int Arbol<T>::getAltura(ablNodo<T>*& pos){
if(pos == nullptr){
return 0;
}
int altuIzquie = getAltura(pos->gethijoIzq());
int altuDere = getAltura(pos->gethijoDer());
if (altuIzquie > altuDere) {
return altuIzquie + 1;
}else{
return altuDere + 1;
}
}
template <class T>
ablNodo<T>*& Arbol<T>::busDato (ablNodo<T>*& pos,
T& e){
if(pos == nullptr || e == pos->getDato()){
return pos;
}
if(e < pos->getDato()){
return busDato(pos->gethijoIzq(), e);
}
else{
return busDato(pos->gethijoDer(), e);
}
}
template <class T>
ablNodo<T>*& Arbol<T>::getMenor(ablNodo<T>*& pos){
if(pos == nullptr){
return nullptr;
}
ablNodo<T>*& aux = pos;
while (aux->gethijoIzq() != nullptr) {
aux = aux->gethijoIzq();
}
return aux;

}
template <class T>
ablNodo<T>*& Arbol<T>::getMayor(ablNodo<T>*& pos){
if(pos == nullptr){
return nullptr;
}
ablNodo<T>*& aux = pos;
while (aux->gethijoDer() != nullptr) {
aux = aux->gethijoDer();
}
return aux;
}
//Equilibrio arbol
//*************************************************
****************
template <class T>
short Arbol<T>::getFacEqui(ablNodo<T>*& pos){
return getAltura(pos->gethijoDer()) getAltura(pos->gethijoIzq());
}
template <class T>
void Arbol<T>::rotSimplDere(ablNodo<T>*& pos){
cout<< "RSD:["<<pos->getDato()<<"]"<<endl;
ablNodo<T>* aux1 = pos->gethijoIzq();
ablNodo<T>* aux2 = aux1->gethijoDer();
pos->sethijoIzq(aux2);
aux1->sethijoDer (pos);
pos = aux1;
}

template <class T>

void Arbol<T>::rotDobleDere(ablNodo<T>*& pos){
cout<< "RDD:["<<pos->getDato()<<"]"<<endl;
rotSimplIzqu(pos->gethijoIzq());
rotSimplDere(pos);
}
template <class T>
void Arbol<T>::rotSimplIzqu(ablNodo<T>*& pos){
cout<< "RSI:["<<pos->getDato()<<"]"<<endl;
ablNodo<T>* aux1 = pos->gethijoDer();
ablNodo<T>* aux2 = aux1->gethijoIzq();
pos->sethijoDer(aux2);
aux1-> sethijoIzq(pos);
pos = aux1;
}
template <class T>
void Arbol<T>::rotDobleIzqu(ablNodo<T>*& pos){
cout<< "RDI:["<<pos->getDato()<<"]"<<endl;
rotSimplDere(pos->gethijoDer());
rotSimplIzqu(pos);
}
template <class T>
void Arbol<T>::eBalance(ablNodo<T>*& pos){
short facBalan = getFacEqui(pos);
if(facBalan == -2){
if(getFacEqui(pos->gethijoIzq())== -1){
rotSimplDere(pos);
}else{
rotDobleDere(pos);
}
}else{
if(facBalan == 2){

if(getFacEqui(pos->gethijoDer()) == 1){
rotSimplIzqu(pos);
}else{
rotDobleIzqu(pos);
}
}

}
//*************************************************
*****************
//Metodos publicos
template <class T>
Arbol<T>::Arbol(){
inicializa();
}
template <class T>
Arbol<T>::~Arbol(){
borraTodo();
}
template <class T>
ablNodo<T>*& Arbol<T>::getIzque(){
return arbl->gethijoIzq();
}
template <class T>
ablNodo<T>*& Arbol<T>::getDerech(){
return arbl->gethijoDer();
}
template <class T>
ablNodo<T>*& Arbol<T>::busDato(T& e){
return busDato(arbl, e);
}
template <class T>
void Arbol<T>::inicializa(){
arbl = nullptr;
}

template <class T>

bool Arbol<T>::etaVacia(){
return arbl == nullptr;
}
template <class T>
void Arbol<T>::inserDato(T& e){
inserDato(arbl, e);
}
template <class T>
void Arbol<T>::borraPos(ablNodo<T>*& pos){
if(pos == nullptr){
throw AblException ("Error de insuficiencia
de datos");
}
if(pos->gethijoIzq() == nullptr && pos>gethijoDer()){
ablNodo<T>*& elPadre = pos->getNodoPadre();
delete pos;
pos = nullptr;
ablNodo<T>*& aux = elPadre;
while (aux != nullptr) {
aux->actualizarPeso();
aux = aux->getNodoPadre();
}
}
else{
ablNodo<T>*& cambiaNodo = getPeso(pos>gethijoIzq());
if(cambiaNodo == nullptr){
cambiaNodo = getMenor(pos>gethijoDer());
}
T sustitulleNodo = cambiaNodo->getDato();
borraPos(cambiaNodo);

pos->setDato(sustitulleNodo);
}
}
template <class T>
void Arbol<T>::borraDato(T& e){
ablNodo<T>*& pos = busDato(e);
if(pos != nullptr){
borraPos(pos);
}
}
template <class T>
void Arbol<T>::imprPreor(){
imprPreor(arbl);
}
template <class T>
void Arbol<T>::imprIno(){
imprIno(arbl);
}
template <class T>
void Arbol<T>::imprPos(){
imprPos(arbl);
}
template <class T>
void Arbol<T>::borraTodo(){
borrarAbl(arbl);
}
template <class T>
int Arbol<T>::getAltura(){
return getAltura(arbl);
}
template <class T>
unsigned Arbol<T>::getPeso(){
return arbl->gethijoIzq()->getPeso();
}
#endif

men.h

//
// Menu.h
// Actividad 13
//
// Created by manuel romero on 23/05/14.
// Copyright (c) 2014 manuel romero. All rights
reserved.
//
#ifndef Actividad_13_Menu_h
#define Actividad_13_Menu_h
#include <iostream>
#include <ctime>
#include <cstdlib>
#include "Arbol.h"
using namespace std;
class menu{
public:
void menuArbol( Arbol<int>);
};
void menu::menuArbol( Arbol<int> Arbo){
int dato,i,temp;
srand(time_t(NULL));
cout<< "Introduce el numero de nodos de
enteros"<<endl;
cin>>temp;
for(i=0; i<temp; i++){
dato = rand()%65536;
cout<<dato<<"-";
Arbo.inserDato(dato);

}
getchar();
getchar();
cout <<endl<< "Contenido
"<< endl;
Arbo.imprPreor();
cout<<endl;
getchar();
cout <<endl<< "Contenido
endl;
Arbo.imprIno();
cout<<endl;
getchar();
cout <<endl<< "Contenido
"<< endl;
Arbo.imprPreor();
cout<<endl;
getchar();
cout<<endl;
cout<<"Altura del arbol:
cout<< Arbo.getAltura();
cout<<endl;
}
#endif

del arbol pre orden

del arbol in orden "<<

del arbol pos orden

";

.cpp

//
// main.cpp
// Actividad 13
//
// Created by manuel romero on 18/05/14.
// Copyright (c) 2014 manuel romero. All rights
reserved.
//
#include <iostream>
#include "Menu.h"
int main()
{
menu me;
me.menuArbol(Arbol<int> ());
}

capturas