#include <cstdlib>

#include <cstring>
#include <sstream>
#include "ArvBin.h"

using namespace std;

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

int ArvBin::getRaiz()
{
if (raiz != NULL)
return raiz->getInfo();
else
{
cout << "Árvore vazia!" << endl;
exit(1);
}
}

void ArvBin::cria(int x, ArvBin *sae, ArvBin *sad)

{
NoArv *p = new NoArv();
p->setInfo(x);
p->setEsq(sae->raiz);
p->setDir(sad->raiz);
raiz = p;
}

void ArvBin::anulaRaiz()
{
raiz = NULL;
}

void ArvBin::montaArvore()
{
if(!vazia())
cout << "Arvore jah montada. So eh possivel a insercao de nos." << endl;
else
{
cout << "Montagem da arvore em pre-ordem:" << endl;
raiz = auxMontaArvore();
}
}

NoArv* ArvBin::auxMontaArvore()
{
string linha;
cout << "Valor: ";
cin >> linha;
if(linha != "NULL" && linha != "null")
{
istringstream ent(linha);
int valor;
ent >> valor;
NoArv *p = new NoArv();
 p->setInfo(valor);
cout << "Esquerda" << endl;
p->setEsq(auxMontaArvore());
cout << "Volta no noh " << p->getInfo() << endl;
cout << "Direita" << endl;
p->setDir(auxMontaArvore());
cout << "Volta no noh " << p->getInfo() << endl;
return p;
}
else
return NULL;
}

void ArvBin::insere(int x)
{
raiz = auxInsere(raiz, x);
}

NoArv* ArvBin::auxInsere(NoArv *p, int x)

{
if(p == NULL)
{
p = new NoArv();
p->setInfo(x);
p->setEsq(NULL);
p->setDir(NULL);
}
else
{
char direcao;
cout << x << " a esquerda (e) ou direita (d) de " << p->getInfo() << ": ";
cin >> direcao;
if(direcao == 'e' || direcao == 'E')
p->setEsq(auxInsere(p->getEsq(), x));
else
p->setDir(auxInsere(p->getDir(), x));
}
return p;
}

bool ArvBin::vazia()
{
return (raiz == NULL);
}

bool ArvBin::busca(int x)
{
return auxBusca(raiz, x);
}

bool ArvBin::auxBusca(NoArv *p, int x)

{
if (p == NULL)
return false;
else if (p->getInfo() == x)
return true;
else if (auxBusca(p->getEsq(), x))
return true;
else
 return auxBusca(p->getDir(), x);
}

ArvBin::~ArvBin()
{
raiz = libera(raiz);
}

NoArv* ArvBin::libera(NoArv *p)

{
if (p != NULL)
{
p->setEsq(libera(p->getEsq()));
p->setDir(libera(p->getDir()));
delete p;
p = NULL;
}
return NULL;
}

void ArvBin::preOrdem()
{
cout << "Arvore Binaria em Pre-Ordem: ";
auxPreOrdem(raiz);
}

void ArvBin::auxPreOrdem(NoArv *p)

{
if (p != NULL)
{
cout << p->getInfo() << " ";
auxPreOrdem(p->getEsq());
auxPreOrdem(p->getDir());
}
}

int ArvBin::contaNos()
{
if(vazia()){
return 0;
} else {
return auxContaNos(raiz);
}

int ArvBin::auxContaNos(NoArv *p)

{
if(p == NULL){
return 0;
}else {
return 1 + auxContaNos(p->getEsq()) + auxContaNos(p->getDir());
}
}

int ArvBin::contaNosFolha()
{
if(vazia()){
return 0;
 } else {
return auxContaNosFolhas(raiz);
}
}

int ArvBin::auxContaNosFolhas(NoArv *p)

{
if(p == NULL){
return 0;
}else if(p->getDir()==NULL && p->getEsq()==NULL){
return 1;
}else{
return auxContaNosFolhas(p->getEsq()) + auxContaNosFolhas(p->getDir());
}
}

int ArvBin::maior(int x, int y)

{
if(x>y)
return x;
else
return y;
}

int ArvBin::altura()
{
if(vazia())
return 0;
else
return auxAltura(raiz);
}

int ArvBin::auxAltura(NoArv *p)

{
int he,hd;

if(p == NULL){
return -1;
}else{
he = auxAltura(p->getEsq());
hd = auxAltura(p->getDir());

return 1 + maior(he,hd);
}
}

int ArvBin::contaImpar()
{
if(vazia()){
cout << "arvore vazia!" << endl;
return -1;
}else {
return auxContaImpar(raiz);
}
}

int ArvBin::auxContaImpar(NoArv *p)

{
if(p != NULL){
 if(p->getInfo() %2 != 0)
return 1 + auxContaImpar(p->getEsq()) + auxContaImpar(p->getDir());
else
return auxContaImpar(p->getEsq()) + auxContaImpar(p->getDir());
}else{
return 0;
}
}

int ArvBin::contaImparFolhas()
{
if(vazia()){
cout << "arvore vazia!" << endl;
return -1;
}else {
return auxContaImparFolhas(raiz);
}
}

int ArvBin::auxContaImparFolhas(NoArv *p)

{
if(p != NULL){
if(p->getInfo() %2 != 0 && p->getDir()==NULL && p->getEsq()==NULL)
return 1 + auxContaImparFolhas(p->getEsq()) + auxContaImpar(p-
>getDir());
else
return auxContaImparFolhas(p->getEsq()) + auxContaImparFolhas(p-
>getDir());
}else{
return 0;
}
}
void ArvBin::imprimeNivel(int x)
{
int h;
h = altura();

if(vazia()){
cout << "arvore vazia!" << endl;
}else if(x<=h){
auxImpNivel(raiz,0,x);
}else{
cout << endl << "nivel invalido!" << endl;
}
}

void ArvBin::auxImpNivel(NoArv *p, int atual, int k)

{
if(atual!=k){
auxImpNivel(p->getEsq(),atual+1,k);
auxImpNivel(p->getDir(),atual+1,k);
}else if(atual==k){
cout << p->getInfo() << " ";
}
}

float ArvBin::mediaNivel(int x)
{
int soma=0;
 int n=0;

if(vazia()){
cout << "arvore vazia!" << endl;
return 0;
}else {
auxMediaNivel(raiz, &soma, &n, x);
}
return (soma/n);
}

void ArvBin::auxMediaNivel(NoArv *p, int *soma, int *n, int k)

{
if(p!=NULL){
if(k==0){
*soma = *soma + p->getInfo();
*n = *n + 1;
}else if(k>0){
auxMediaNivel(p->getEsq(),soma,n,k-1);
auxMediaNivel(p->getDir(),soma,n,k-1);
}
}
}

int ArvBin::minimo()
{
int m = raiz->getInfo();
auxMinimo(raiz,&m);
return m;
}

void ArvBin::auxMinimo(NoArv *p, int *m)

{
if(p != NULL){
if(p->getInfo() < *m){
*m= p->getInfo();
}else{
auxMinimo(p->getEsq(),m);
auxMinimo(p->getDir(),m);
}
}
}

int ArvBin::maximo()
{
int m = raiz->getInfo();
auxMaximo(raiz,&m);
return m;
}

void ArvBin::auxMaximo(NoArv *p, int *m)

{
if(p!=NULL){
if(p->getInfo() > *m){
*m= p->getInfo();
}else{
auxMaximo(p->getEsq(),m);
auxMaximo(p->getDir(),m);
}
 }
}

void ArvBin::inverte()
{
if(vazia()){
cout << "arvore vazia!!" << endl;
}else{
auxInverte(raiz);
}
}

void ArvBin::auxInverte(NoArv *p)

{
int aux;
NoArv *aux2,*aux3;
if(p!=NULL){
if(p->getDir()!= NULL && p->getEsq()!=NULL){
aux2 = p->getEsq();
aux3 = p->getDir();
aux = aux2->getInfo();
aux2->setInfo(aux3->getInfo());
aux3->setInfo(aux);

auxInverte(p->getEsq());
auxInverte(p->getDir());

}else{
auxInverte(p->getEsq());
auxInverte(p->getDir());
}
}
}

int ArvBin::noMaisEsq()
{
if(vazia()){
cout << "arvore vazia!!" << endl;
return 0;
}else{
return auxNoEsq(raiz);
}
}

int ArvBin::auxNoEsq(NoArv *p)

{
if(p->getEsq() == NULL){
return p->getInfo();
}else{
return auxNoEsq(p->getEsq());
}
}

int ArvBin::noMaisDir()
{
if(vazia()){
cout << "arvore vazia!!" << endl;
return 0;
}else{
 return auxNoDir(raiz);
}
}

int ArvBin::auxNoDir(NoArv *p)

{
if(p->getDir() == NULL){
return p->getInfo();
}else{
return auxNoDir(p->getDir());
}
}

int ArvBin::minSubArvore(NoArv *p)

{
int m = p->getInfo();
auxMinimo(p,&m);
return m;
}

int ArvBin::maxSubArvore(NoArv *p)

{
int m = p->getInfo();
auxMaximo(p,&m);
return m;
}

bool ArvBin::ehABB()
{
return auxEhABB(raiz);
}

bool ArvBin::auxEhABB(NoArv *p)

{
if(p == NULL)
return true; //se a arvore for vazia ela é ABB
if(p->getEsq() != NULL && p->getInfo() < (minSubArvore(p->getEsq())))
return false
if(p->getDir() != NULL && p->getInfo() > (maxSubArvore(p->getDir())))
return false
return auxEhABB(p->getEsq()) && auxEhABB(p->getDir());