Implementar um método que retorne os n maiores numero da árvore abaixo

[silulem]

Saudações,

Por Favor alguém que me ajude,
Tenho esta árvore abaixo, pediram-me para implementar o Metodo Pre-Ordem , Pos-Ordem e implementar um método que retorne os N maiores numero da Árvore abaixo.

O método Pre-Ordem e Pos-Ordem , já foram implementados , mas não consigo implementar o método que retorne  maior numero da árvore.

Alguém pode ajudar-me.

 

 

//#include <iostream>
//using namespace std;
//classe arvore binaria de busca para valores inteiros
class CArvore
{
private:
         int * Raiz;
         CArvore * Esq, *Dir;
public:
CArvore();
CArvore(int raiz);
CArvore(int raiz, CArvore * esq, CArvore * dir);
void Adicionar(int elem);
bool Buscar(int elem);
bool EVazia();
void Eliminar(int elem);
void PreOrdem();
void PosOrdem();
void OrdemSimetrica();
CArvore& operator =(const CArvore&);
};
//------------------------------------------------------------ CONSTRUTORES
         CArvore:: CArvore()
         {
                 Raiz = NULL;
                 Esq = NULL;
                 Dir = NULL;
         }
//------------------------------------------------------------
         CArvore::CArvore(int raiz)
         {
                 Raiz = new int;
                 *Raiz = raiz;
                 Esq = new CArvore();
                 Dir = new CArvore();
         }
//--------------------------------------------------------------
         CArvore::CArvore(int raiz, CArvore * esq, CArvore * dir)
         {
                 Raiz = new int;
                 *Raiz = raiz;
                 Esq = esq;
                 Dir = dir;
         }
//---------------------------------------------------------------- ADICIONAR
         void CArvore::Adicionar(int elem)
         {
                 if(EVazia())
                 {
                 Raiz = new int;
                 *Raiz = elem;
                 Esq = new CArvore();
                 Dir = new CArvore();
                 }
                 else
                 {
                 if (elem < *Raiz)
                 Esq->Adicionar(elem);
                 else
                 Dir->Adicionar(elem);
                 }
         }
//---------------------------------------------------------------- BUSCAR
         bool CArvore::Buscar(int elem)
         {
         if(!EVazia())
                 {
                 if(elem == *Raiz)
                         return true;
                 else if(elem > *Raiz)
                         return Dir->Buscar(elem);
                 else
                         return Esq->Buscar(elem);
                 }
         else return false;
         }

//------------------------------------------------------------------- EVAZIA
         bool CArvore::EVazia()
         {
                 if(Raiz == NULL)
                         return true;
                 else return false;
         }
//---------------------------------------------------------------- ELIMINAR
void CArvore::Eliminar(int elem)
{
if(!EVazia())
{
         if(elem == *Raiz)
         {
CArvore* aux;
                         if(Esq->EVazia())
                         {
                         delete Esq;
         aux = Dir;
         *this = *aux;
         delete aux;
                         }
                         else
                         if(Dir->EVazia())
                         {
                         delete Dir;
         aux = Esq;
                         *this = *Esq;
         delete aux;
                         }
                         else
                         {
                         CArvore* sucessor = Dir;
                         while(!sucessor->Esq->EVazia())
                                 sucessor = sucessor->Esq;
                         *Raiz = *sucessor->Raiz;
                         delete sucessor->Esq;
         aux = sucessor->Dir;
                         *sucessor = *sucessor->Dir;
         delete aux;
                 }
                 }
                 else
                 if(elem < *Raiz)
                         Esq->Eliminar(elem);
                 else
                         Dir->Eliminar(elem);
}
}
//--------------------------------------------------------------- Pré-ORDEM
         void CArvore::PreOrdem()
         {
                 if(!EVazia())
                 {
cout << *Raiz << ", ";
if(!Esq->EVazia())
                 Esq->PreOrdem();
                 if(!Dir->EVazia())
                         Dir->PreOrdem();
                 }
         }
//--------------------------------------------------------------- Pós-ORDEM
         void CArvore::PosOrdem()
         {
                 if(!EVazia())
                 {
                 if(!Esq->EVazia())
                 Esq->PosOrdem();
                 if(!Dir->EVazia())
                         Dir->PosOrdem();
                 cout << *Raiz << ", ";
                 }
         }
//--------------------------------------------------------------- ORDEM SIMETRICA
         void CArvore::OrdemSimetrica()
         {
                 if(!EVazia())
                 {
                 if(!Esq->EVazia())
                 Esq->OrdemSimetrica();
                 cout << *Raiz << ", ";
                 if(!Dir->EVazia())
                         Dir->OrdemSimetrica();
                 }
         }
//----------------------------------------------------------------- OPERADOR =
CArvore& CArvore::operator =(const CArvore& x)
         {
this->Raiz = x.Raiz;
Dir = x.Dir;
Esq = x.Esq;
return *this;
}

 

[1freakday]

Você só precisa criar uma função que verifique todos valores da arvore,esq,dir, e armazenar o maior valor, ate encontrar o maior de todos.