Pres

entación
Nombre:
Yerinson Manuel Figuereo Corcino
Matricula:
A00108759
Profesor:
Omar Antonio de Jesús de la Cruz Gonzales
Materia:
Programación y estructura de datos
Título:
Práctica de Programación en C++ (Arboles)
Desarrollar una clase para la administración de un árbol binario ordenado.
#include <iostream>

using namespace std;

class ArbolBinario {
private:
class Nodo {
public:
int info;
Nodo* izq;
Nodo* der;
};
Nodo* raiz;
void borrar(Nodo* reco);
void imprimirPre(Nodo* reco);
void imprimirEntre(Nodo* reco);
void imprimirPost(Nodo* reco);
public:
ArbolBinario();
~ArbolBinario();
void insertar(int x);
void imprimirPre();
void imprimirEntre();
void imprimirPost();
};

ArbolBinario::ArbolBinario()
{
raiz = NULL;
}

ArbolBinario::~ArbolBinario()
{
borrar(raiz);
}

void ArbolBinario::borrar(Nodo* reco)

{
if (reco != NULL)
{
borrar(reco->izq);
borrar(reco->der);
delete reco;
}
}

void ArbolBinario::insertar(int x)
{
Nodo* nuevo;
nuevo = new Nodo();
nuevo->info = x;
nuevo->izq = NULL;
nuevo->der = NULL;
if (raiz == NULL)
raiz = nuevo;
 else
{
Nodo* anterior, * reco;
anterior = NULL;
reco = raiz;
while (reco != NULL)
{
anterior = reco;
if (x < reco->info)
reco = reco->izq;
else
reco = reco->der;
}
if (x < anterior->info)
anterior->izq = nuevo;
else
anterior->der = nuevo;
}
}

void ArbolBinario::imprimirPre()
{
imprimirPre(raiz);
cout << "\n";
}

void ArbolBinario::imprimirPre(Nodo* reco)

{
if (reco != NULL)
{
cout << reco->info << "-";
imprimirPre(reco->izq);
imprimirPre(reco->der);
}
}

void ArbolBinario::imprimirEntre()
{
imprimirEntre(raiz);
cout << "\n";
}

void ArbolBinario::imprimirEntre(Nodo* reco)

{
if (reco != NULL)
{
imprimirEntre(reco->izq);
cout << reco->info << "-";
imprimirEntre(reco->der);
}
}

void ArbolBinario::imprimirPost()
{
imprimirPost(raiz);
cout << "\n";
}
void ArbolBinario::imprimirPost(Nodo* reco)
{
if (reco != NULL)
{
imprimirPost(reco->izq);
imprimirPost(reco->der);
cout << reco->info << "-";
}
}

int main()
{
ArbolBinario* arbol = new ArbolBinario();
arbol->insertar(100);
arbol->insertar(45);
arbol->insertar(25);
arbol->insertar(35);
arbol->insertar(150);
cout << "Impresion preorden: ";
cout << "\n";
arbol->imprimirPre();
cout << "Impresion entreorden: ";
cout << "\n";
arbol->imprimirEntre();
cout << "Impresion postorden: ";
cout << "\n";
arbol->imprimirPost();
delete arbol;
return 0;
}
Confeccionar una clase que permita insertar un entero en un árbol binario ordenado verificando
que no se encuentre previamente dicho número.

Desarrollar los siguientes métodos.

1- Retomar la cantidad de nodos del árbol.

2- Retomar la cantidad de nodos hojas del árbol.
3- Imprimir en entre orden.
4- Imprimir en entre orden junto al nivel donde se encuentre dicho nodo.
5- Retomar la altura del árbol.
6- Imprimir el mayor del árbol.
7- Borrar el nodo del menor árbol.

#include <iostream>

using namespace std;

class ArbolBinario {
private:
class Nodo {
public:
int info;
Nodo* izq;
Nodo* der;
};
Nodo* raiz;
int cant;
int altura;
void borrar(Nodo* reco);
void imprimirEntre(Nodo* reco);
void cantidad(Nodo* reco);
void cantidadNodosHoja(Nodo* reco);
void imprimirEntreConNivel(Nodo* reco, int nivel);
void retornarAltura(Nodo* reco, int nivel);
public:
ArbolBinario();
~ArbolBinario();
void insertar(int x);
bool existe(int x);
void imprimirEntre();
int cantidad();
int cantidadNodosHoja();
void imprimirEntreConNivel();
int retornarAltura();
void mayorValor();
void borrarMenor();
};

ArbolBinario::ArbolBinario()
{
raiz = NULL;
}

ArbolBinario::~ArbolBinario()
{
borrar(raiz);
}

void ArbolBinario::borrar(Nodo* reco)

{
if (reco != NULL)
{
borrar(reco->izq);
borrar(reco->der);
delete reco;
}
}

void ArbolBinario::insertar(int x)
{
if (!existe(x))
{
Nodo* nuevo;
nuevo = new Nodo();
nuevo->info = x;
nuevo->izq = NULL;
nuevo->der = NULL;
if (raiz == NULL)
raiz = nuevo;
else
{
Nodo* anterior, * reco;
anterior = NULL;
reco = raiz;
while (reco != NULL)
{
anterior = reco;
if (x < reco->info)
reco = reco->izq;
else
reco = reco->der;
}
if (x < anterior->info)
anterior->izq = nuevo;
else
anterior->der = nuevo;
}
}
}

bool ArbolBinario::existe(int x)
{
Nodo* reco = raiz;
while (reco != NULL)
{
if (x == reco->info)
return true;
else
if (x > reco->info)
reco = reco->der;
else
 reco = reco->izq;
}
return false;
}

int ArbolBinario::cantidad()
{
cant = 0;
cantidad(raiz);
return cant;
}

void ArbolBinario::cantidad(Nodo* reco)

{
if (reco != NULL)
{
cant++;
cantidad(reco->izq);
cantidad(reco->der);
}
}

int ArbolBinario::cantidadNodosHoja()
{
cant = 0;
cantidadNodosHoja(raiz);
return cant;
}

void ArbolBinario::cantidadNodosHoja(Nodo* reco)

{
if (reco != NULL) {
if (reco->izq == NULL && reco->der == NULL)
cant++;
cantidadNodosHoja(reco->izq);
cantidadNodosHoja(reco->der);
}
}

void ArbolBinario::imprimirEntreConNivel()
{
imprimirEntreConNivel(raiz, 1);
cout << "\n";
}

void ArbolBinario::imprimirEntreConNivel(Nodo* reco, int nivel)

{
if (reco != NULL) {
imprimirEntreConNivel(reco->izq, nivel + 1);
cout << reco->info << "(" << nivel << ") - ";
imprimirEntreConNivel(reco->der, nivel + 1);
}
}

int ArbolBinario::retornarAltura()
{
altura = 0;
retornarAltura(raiz, 1);
return altura;
}

void ArbolBinario::retornarAltura(Nodo* reco, int nivel)

{
if (reco != NULL)
{
retornarAltura(reco->izq, nivel + 1);
if (nivel > altura)
altura = nivel;
retornarAltura(reco->der, nivel + 1);
}
}

void ArbolBinario::mayorValor()
{
if (raiz != NULL)
{
Nodo* reco = raiz;
while (reco->der != NULL)
reco = reco->der;
cout << "Mayor valor del árbol:" << reco->info;
}
}

void ArbolBinario::borrarMenor()
{
if (raiz != NULL) {
Nodo* bor;
if (raiz->izq == NULL)
{
bor = raiz;
raiz = raiz->der;
delete bor;
}
else {
Nodo* atras = raiz;
Nodo* reco = raiz->izq;
while (reco->izq != NULL)
{
atras = reco;
reco = reco->izq;
}
atras->izq = reco->der;
delete reco;
}
}
}

void ArbolBinario::imprimirEntre()
{
imprimirEntre(raiz);
cout << "\n";
}
void ArbolBinario::imprimirEntre(Nodo* reco)
{
if (reco != NULL)
{
imprimirEntre(reco->izq);
cout << reco->info << "-";
imprimirEntre(reco->der);
}
}

int main()
{
ArbolBinario* arbol1 = new ArbolBinario();
arbol1->insertar(100);
arbol1->insertar(45);
arbol1->insertar(25);
arbol1->insertar(35);
arbol1->insertar(150);
cout << "Impresion entre orden: ";
cout << "\n";
arbol1->imprimirEntre();
cout << "\n";
cout << "Cantidad de nodos del árbol:" << arbol1->cantidad() << "\n";
cout << "\n";
cout << "Cantidad de nodos hoja:" << arbol1->cantidadNodosHoja() << "\n";
cout << "\n";
cout << "Impresion en entre orden junto al nivel del nodo:";
cout << "\n";
arbol1->imprimirEntreConNivel();
cout << "\n";
cout << "Artura del arbol:";
cout << "\n";
cout << arbol1->retornarAltura();
cout << "\n";
arbol1->mayorValor();
cout << "\n";
arbol1->borrarMenor();
cout << "\n";
cout << "Luego de borrar el menor:";
arbol1->imprimirEntre();
delete arbol1;
return 0;
}