Classe btree com novos métodos

/* Essa classe deu muito trabalho, pois dava um erro mais estranho que o outro, mas graças a ajuda do Enari, finalmente funcionou, com os ultimos metodos pedidos em sala. A representação da arvore no método parenteses foi feita de maneira recursiva, baseando-se no metodo ShowPreOrdem, apenas alterando algumas coisas como a abrtura de parenteses no inicio da chamada recursiva e fechando no retorno da chamada. A Hierarquica II (metodo hierarquica), tivemos um pouco mais de trabalho, pois não estavamos conseguindo alinhar de forma correta os caracteres na tela, mas com ajudar do Igor, ficou certinho. O Hierarquica I(metodo hiera) foi nossa "vingança" com o Igor, pois conseguimos mostrar para ele um forma mais pratica desta representação, onde fizemos nos basenado no metodo ShowCentral, apenas alternado a forma de impressão na tela.*/

#ifndef _BTREE_H
#define _BTREE_H

#include

using namespace std;

class node; // prototipo da classe node

typedef node *ptrno; // criando um tipo de dados ptrno ponteiro para node

/*
Construcao da classe node.
*/

class node{
private:
int valor;
ptrno esq, dir;
public:
node(){valor=0; esq=dir=NULL;}
node(int v){valor=v; esq=dir=NULL;}
void setValor(int v){valor=v;}
void setEsq(ptrno e){esq=e;}
void setDir(ptrno d){dir=d;}
int getValor(){return valor;}
ptrno getEsq(){return esq;}
ptrno getDir(){return dir;}
};

class btree{
private:
ptrno raiz;
// as chamadas recursivas sao privadas e soh podem ser executadas a partir de metodos do objeto.
void push(ptrno &, int);
void showCentral(ptrno);
void showPreOrdem(ptrno);
void showPosOrdem(ptrno);
void showFolhas(ptrno);
void parenteses(ptrno);
void hierarquica(ptrno, int);
void hiera(ptrno, int);
public:
btree(){raiz = NULL;}
ptrno getRaiz(){return raiz;}
// a seguir, as interfaces de funcoes recursivas
void push(int v);
void showCentral();
void showPreOrdem();
void showPosOrdem();
void showFolhas();
void parenteses();
void hierarquica();
void hiera();
};

// interface publica da funcao recursiva push (insere um novo nó na btree)
void btree::push(int v){
push(raiz, v);
}

// rotina push a ser chamada pela interface publica (insere um novo no na subarvore cuja raiz eh r
void btree::push(ptrno &r, int v){
ptrno aux;
if (r!=NULL){ // se o no atual nao for NULL, a insercao deve ser feita em uma das subarvores (esq ou dir)
if (v > r->getValor()){ // v eh maior que o valor do no e deve ser inserido na subarvore direita
aux=r->getDir();
push(aux, v);
r->setDir(aux);
}
else{ // v nao eh maior que o valor do no e deve ser inserido na subarvore esquerda
aux=r->getEsq();
push(aux, v);
r->setEsq(aux);
} // note que o objeto aux eh utilizado para recuperar possiveis alteracoes na subarvore
}
else{ // o trecho seguinte eh executado se no caminhamento pela arvore cairmos em um node NULL (r==NULL),
// o que indica que eh a posicao onde o valor deve ser inserido
aux=new(node); // usando construtor da classe node, valor=0, esq=dir=NULL (vide node())
aux->setValor(v);
r=aux;
}
}

void btree::showCentral(){
showCentral(raiz);
}

void btree::showCentral(ptrno r){ // caminhamento ESQ - RAIZ - DIR
if(r!=NULL){
showCentral(r->getEsq()); // imprime toda a subarvore ESQ com caminhamento central
cout <<>getValor() << " "; // imprime o valor armazenado na raiz
showCentral(r->getDir()); // imprime toda a subarvore DIR com caminhamento central
}
}

void btree::showPreOrdem(){
showPreOrdem(raiz);
}

void btree::showPreOrdem(ptrno r){ // caminhamento RAIZ - ESQ - DIR
if(r!=NULL){
cout <<>getValor() << " ";
showPreOrdem(r->getEsq());
showPreOrdem(r->getDir());
}
}

void btree::showPosOrdem(){
showPosOrdem(raiz);
}

void btree::showPosOrdem(ptrno r){ // caminhamento ESQ - DIR - RAIZ
if(r!=NULL){
showPosOrdem(r->getEsq());
showPosOrdem(r->getDir());
cout <<>getValor() << " ";
}
}

void btree::showFolhas(){
showFolhas(raiz);
}

void btree::showFolhas(ptrno r){ // imprime folhas por caminhamento ESQ - RAIZ - DIR
if(r!=NULL){
showFolhas(r->getEsq()); // imprime toda as folhas da subarvore ESQ com caminhamento central
if(r->getEsq()==NULL && r->getDir()==NULL) cout <<>getValor() << " "; // imprime o valor armazenado na raiz, se ela for folha
showFolhas(r->getDir()); // imprime toda as folhas da subarvore DIR com caminhamento central
}
}


//teste


void btree::parenteses(){
parenteses(raiz);
}

void btree::parenteses(ptrno r){
if(r!=NULL){
cout<< "("<<" ";

cout<getValor();

parenteses(r->getEsq());

parenteses(r->getDir());

cout<< ")"<<" ";

}

}


void btree::hierarquica(){
hierarquica(raiz, 0);
}

void btree::hierarquica(ptrno r, int x){
if(r!=NULL){

cout<
for(int i = 0; i < x*3; i++){

cout << " "; }

cout<<"|-";

cout<getValor()<
hierarquica(r->getEsq(), x+1);

hierarquica(r->getDir(), x+1);

}
}


void btree::hiera(){
hiera(raiz, 20);
}

void btree::hiera(ptrno r, int x){
if(r!=NULL){

hiera(r->getEsq(), x-3);
cout<
for(int i = 0; i < x; i++){

cout << " "; }

cout <<>getValor()<< " ";

hiera(r->getDir(), x-3);
}
}

#endif