Criando a Classe Árvore

A partir da Classe Principal da Postagem anterior vamos criar a Classe da Árvore
Binária e a partir dela realizar algumas tarefas:

class btree{ //Esta é a classe da árvore binária
private:
ptrno raiz;
public:
btree () {raiz=NULL;}

void push (int); //Neste ponto começa a ser declarada as funções que irão
void push (ptrno &r, int v); // realizar as tarefas.
int maior();
int maior(ptrno r);
int menor();
int menor (ptrno r);
int size ();
int size(ptrno r);
int a();
int a(ptrno h);
void impinternos ();
int impinternos(ptrno r);
};

//Acima estão apenas as chamadas de cada função. O que cada uma realmente deve fazer segue abaixo:

// A função push irá adicionar valores para a árvore, lembrando que neste caso os valores serão colocados em ordem crescente.

void btree::push (int v){
push (raiz,v);
}

void btree::push (ptrno &r, int v)
{
ptrno aux;
if (r==NULL)
{
r = new (node);
r->setValor (v);
r->setEsq(NULL);
r->setDir(NULL);
}
else
if (v>r->getValor())
{
aux = r->getDir();
push (aux, v);
r->setDir(aux);
}
else aux=r->getEsq();
push (aux, v);
r->setEsq(aux);
}

/* A função maior irá retornar o maio valor que a árvore possuir. Aqui ela foi resolvida de duas maneiras: uma usando recursidade(o problema maior dividido em problemas menores com as mesmas características), e usando interatividade (da maneira básica).
*/

int btree::maior() {
return maior (raiz);
}

int btree::maior (ptrno r){ //RECURSIVIDADE
if (r==NULL)
return 0;
if (r->getDir()== NULL)
return r->getValor();
else
return maior (r->getDir());
}

/* int btree::maior(){ //INTERATIVIDADE
ptrno aux= raiz;
if (aux==NULL)
return 0;
while (aux->getdir()!=NULL)
aux=aux->getdir();
return aux->getvalor();
}
*/

// Função menor irá retornar o menor valor da árvore
int btree::menor() {
return menor (raiz);
}
int btree::menor (ptrno r){
if (r==NULL)
return 0;
if (r->getDir()== NULL)
return r->getValor();
else
return menor (r->getDir());
}

// Função size retorna a quantidade de valores armazenados na árvore
int btree:: size (){
return size(raiz);
}

int btree::size(ptrno r){
if (r!=NULL)
return 1 + size (r->getEsq()) + size(r->getDir());
else
return 0;
}

// a função a retorna a altura da árvore binária
int btree:: a(){
return a(raiz);
}


int btree::a(ptrno r){
if (r!=NULL)
return 1 + max (a(r->getEsq()), a(r->getEsq()));
else
return 0;
}

int max (int a, int b){
if (a > b)
return a;
else
return b;
}

// a função impinternos imprime os valores dos nós internos
void btree::impinternos (){
impinternos(raiz);}

int btree::impinternos(ptrno r){
if (r!=NULL)
if (r->getEsq()!=NULL || r->getDir()!=NULL)
cout <<>getValor() <getEsq());
impinternos (r->getDir());
}

Abaixo segue a função main do código:

int main()
{
btree arvore;

arvore.push(); //Lembrando que dentro dos parênteses devem ser colocados os
arvore.maior(); //valores que serão armazenados na árvore.
arvore.menor();
arvore.size ();
arvore.a();
arvore.impinternos ();

getch();
}