Este es el codigo principal de mis clases:
Clase nodo
Código:
#ifndef NODO_H_
#define NODO_H_
template <class T>
class nodo
{
protected:
T elem;
nodo<T> *hijo_izq;
nodo<T> *hijo_der;
public:
nodo(T e, nodo<T> *i, nodo<T> *d);
T get_elem();
nodo<T> *get_hijo_izq();
nodo<T> *get_hijo_der();
void set_elem(T e);
void set_hijo_izq(nodo<T> *p);
void set_hijo_der(nodo<T> *p);
};
template <class T>
nodo<T>::nodo(T e, nodo<T> *i, nodo<T> *d)
{
elem = e;
hijo_izq = i;
hijo_der = d;
}
template <class T>
T nodo<T>::get_elem()
{
return elem;
}
template <class T>
nodo<T> *nodo<T>::get_hijo_izq()
{
return hijo_izq;
}
template <class T>
nodo<T> *nodo<T>::get_hijo_der()
{
return hijo_der;
}
template <class T>
void nodo<T>::set_elem(T e)
{
elem = e;
}
template <class T>
void nodo<T>::set_hijo_izq(nodo<T> *p)
{
hijo_izq = p;
}
template <class T>
void nodo<T>::set_hijo_der(nodo<T> *p)
{
hijo_der = p;
}
#endif
Y la clase Arbol:
Código:
#ifndef ARBIN_H_
#define ARBIN_H_
#include "nodo.h"
#include "Cola.h"
#include <stddef.h>
#include <iostream>
using namespace std;
template <class T>
class arbin
{
protected:
nodo<T> *raiz;
public:
arbin();
arbin(nodo<T> *p);
bool es_nulo() { return raiz == NULL;}
nodo<T> *get_raiz();
T get_info();
nodo<T> *get_hijo_izq();
nodo<T> *get_hijo_der();
void crear(T e, nodo<T> *a1, nodo<T> *a2);
void crear2(T e, arbin<T> a1, arbin<T> a2);
void ins_hijo_izq(nodo<T> *p);
void ins_hijo_der(nodo<T> *p);
void preorden();
void inorden();
void postorden();
void niveles();
};
template <class T>
arbin<T>::arbin()
{
raiz = NULL;
}
template <class T>
arbin<T>::arbin(nodo<T> *p)
{
raiz = p;
}
template <class T>
T arbin<T>::get_info()
{
return (raiz->get_elem());
}
template <class T>
nodo<T> *arbin<T>::get_raiz()
{
return raiz;
}
template <class T>
nodo<T> *arbin<T>::get_hijo_izq()
{
return (raiz->get_hijo_izq());
}
template <class T>
nodo<T> *arbin<T>::get_hijo_der()
{
return (raiz->get_hijo_der());
}
template <class T>
void arbin<T>::crear(T e, nodo<T> *a1, nodo<T> *a2)
{
nodo<T> *aux;
aux = new nodo<T>(e, a1, a2);
raiz = aux;
}
template <class T>
void arbin<T>::crear2(T e, arbin<T> a1, arbin<T> a2)
{
nodo<T> *aux;
aux = new nodo<T>(e, a1.get_raiz(), a2.get_raiz());
raiz = aux;
}
template <class T>
void arbin<T>::ins_hijo_izq(nodo<T> *p)
{
raiz->set_hijo_izq(p);
}
template <class T>
void arbin<T>::ins_hijo_der(nodo<T> *p)
{
raiz->set_hijo_der(p);
}
template <class T>
void arbin<T>::preorden()
{
nodo<T> *aux;
aux = raiz;
arbin<T> *hd, *hi;
hi = new arbin<T>(aux->get_hijo_izq());
hd = new arbin<T>(aux->get_hijo_der());
cout << aux->get_elem() << endl;
if(!hi->es_nulo())
hi->preorden();
if(!hd->es_nulo())
hd->preorden();
}
template <class T>
void arbin<T>::inorden()
{
nodo<T> *aux;
aux = raiz;
arbin<T> *hd, *hi;
hi = new arbin<T>(aux->get_hijo_izq());
hd = new arbin<T>(aux->get_hijo_der());
if(!hi->es_nulo())
hi->inorden();
cout << aux->get_elem() << endl;
if(!hd->es_nulo())
hd->inorden();
}
template <class T>
void arbin<T>::postorden()
{
nodo<T> *aux;
aux = raiz;
arbin<T> *hd, *hi;
hi = new arbin<T>(aux->get_hijo_izq());
hd = new arbin<T>(aux->get_hijo_der());
if(!hi->es_nulo())
hi->postorden();
if(!hd->es_nulo())
hd->postorden();
cout << aux->get_elem() << endl;
}
template <class T>
void arbin<T>::niveles()
{
Cola< nodo<T> *> c1;
arbin<T> *aux;
nodo<T> *p;
cout << aux->get_info() << endl;
c1.encolar(aux->get_hijo_izq());
c1.encolar(aux->get_hijo_der());
while(!c1.esvacia())
{
p = c1.frente();
cout << p->get_elem() << endl;
c1.encolar(p->get_hijo_izq());
c1.encolar(p->get_hijo_der());
c1.desencolar();
}
}
#endif
Y pues mi idea para el constructor, es algo asi como un procedimiento que recorra el arbol origen de manera recursiva y cree los nuevos nodos a medida que lo recorre y al retornar asigne los hijos de cada nodo de modo que quede todo enlazado.
Pero no he escrito ningun codigo porque no veo la manera de hacerlo. Se que es confuso porque los codigos son algo muy personal pero cualquier consejo o idea es bienvenido.
Gracias