/*!
* Remove um determinado dado da árvore
*
* @param dado Dado a ser removido da árvore
* @param arv Árvore a qual será iniciada a busca pelo dado a ser removido
*/
NoAVL<T>* remover(NoAVL<T>* arv, const T& dado) {
NoAVL<T>* temporario;
NoAVL<T>* filho;
if (arv == NULL) {
return arv;
} else if (dado < *(arv->getDado())) {
arv->esquerda = this->remover(arv->getEsquerda(), dado);
return balancear(arv);
} else if (dado > *(arv->getDado())) {
arv->direita = this->remover(arv->getDireita(), dado);
return balancear(arv);
} else if (arv->getDireita() != NULL &&
arv->getEsquerda() != NULL) {
temporario = this->minimo(arv->getDireita());
arv->dado = new T(static_cast<T const&>(*(temporario->
getDado())));
arv->direita = remover(arv->getDireita(),
*(temporario->getDado()));
return balancear(arv);
} else if (arv->getDireita() != NULL) {
filho = arv->getDireita();
return balancear(filho);
} else if (arv->esquerda != NULL) {
filho = arv->getEsquerda();
return balancear(filho);
}
delete arv;
return NULL;
}
void Binary_tree::balancear(Binary_node *visit) {
static int i = 0;
static vector<int> v[50];
if (v->back()!= NULL){
if (visit != NULL) {
balancear(visit->left);
v[i]->insert(i,visit->key);
i++;
balancear(visit->right);
}
}
}
No* Arvore::adicionar(const float cValor, No* pNo)
{
if(cValor < pNo->getValor())
{
if(pNo->getEsquerda())
{
pAux3 = adicionar(cValor, pNo->getEsquerda());
if(pAux3)
{
pNo->setEsquerda(pAux3);
}
altura(pNo);
pAux3 = balancear(pNo);
}
else
{
pNo->setEsquerda(new No(cValor));
return NULL;
}
}
else
{
if(pNo->getDireita())
{
pAux3 = adicionar(cValor, pNo->getDireita());
if(pAux3)
{
pNo->setDireita(pAux3);
}
altura(pNo);
pAux3 = balancear(pNo);
}
else
{
pNo->setDireita(new No(cValor));
return NULL;
}
}
return pAux3;
}
/* inserir
* Esta função recebe uma AVL, a direção para onde a AVL vai rodar,
* a informação que se deseja inserir, um apontador que serve com flag
* para balanciamento, e uma função de comparação. Insere a informação
* num dos nodos e balanceia a árvore de modo a manter a diferença de
* altura entre estes menor ou igual a 1.
*/
AVL inserir(AVL t, int dir, void *data, int* cresceu,int(*comp)(void*,void*)) {
t->filho[dir] = inserirAVL(t->filho[dir],data,cresceu,comp);
if (*cresceu) {
if (t->factor_balanceamento==!dir) {
t->factor_balanceamento=EQUAL;
*cresceu=0;
}
else if (t->factor_balanceamento==EQUAL) {
t->factor_balanceamento=dir;
*cresceu=1;
}
else if (t->factor_balanceamento==dir) {
t=balancear(t,dir);
*cresceu=0;
}
}
return t;
}
/*!
* Insere um determinado dado na árvore
*
* @param dado Dado a ser inserido na árvore
* @param arv Árvore em que o dado vai ser inserido
*/
NoAVL<T>* inserir(const T& dado, NoAVL<T>* arv) {
NoAVL<T>* novo;
if (dado < *(arv->getDado())) {
if (arv->getEsquerda() == NULL) {
novo = new NoAVL<T>(dado);
arv->esquerda = novo;
} else {
arv->esquerda = this->inserir(dado, arv->getEsquerda());
}
} else if (dado > *(arv->getDado())) {
if (arv->getDireita() == NULL) {
novo = new NoAVL<T>(dado);
arv->direita = novo;
} else {
arv->direita = this->inserir(dado, arv->getDireita());
}
}
return balancear(arv);
}
