/// <summary>
/// Método que verifica se a árvore está desbalanceada, e caso estaja, realiza balanceamento.
/// </summary>
/// <param name="tree">Árvore a ser balanceada.</param>
/// <returns>Árvore já balanceada.</returns>
public AVL balance(AVL tree)
{
// Atualiza a altura do nó e verifica o estado de balanceamento.
switch (updateHeight(tree))
{
// Está desbalanceada a direita. Realiza rotação no filho da direita.
case 2: tree = rotateRight(tree);
break;
// Está desbalanceada a esquerda. Realiza rotação no filho da esquerda.
case -2: tree = rotateLeft(tree);
break;
}
// Retorna a árvore já balanceada.
return(tree);
}
/// <summary>
/// Metodo para rotacionar o elemento a esquerda
/// </summary>
/// <param name="tree">Elemento a ser rotacionado</param>
/// <returns>Árvore balanceada</returns>
public AVL rotateLeft(AVL tree)
{
// Variável auxiliar.
AVL aux = tree;
// Filho esquerdo.
AVL leftChild = (AVL)tree.getLeftChild();
// Filho direito do filho esquerdo.
AVL subTree2 = (AVL)leftChild.getRightChild();
// Rotação
leftChild.setRightChild(tree);
tree.setLeftChild(subTree2);
// Atualiza altura dos nós
updateHeight(tree);
switch (updateHeight(leftChild))
{
// Caso a rotação simples não funicone, é realizada uma rotação dupla.
case -2: leftChild.setRightChild(rotateLeft((AVL)leftChild.getRightChild()));
leftChild = rotateRight(leftChild);
break;
}
// Árvore balanceada.
return(leftChild);
}
/// <summary>
/// Método para deletar uma chave na estrutura.
/// </summary>
/// <param name="key">Chave do nó.</param>
/// <returns>Flag para sucesso/erro da operação.</returns>
public override bool deleteKey(Key key)
{
// Variável de retorno. Considerando erro na operação.
bool result = false;
// Verifica se a chave passada é nula
if (KEY != null)
{
// Compara o valor da chave passada com a do nó atual.
switch (key.VALUE.CompareTo(KEY.VALUE))
{
// Caso seja igual, o nó será deletado.
case 0: if ((getLeftChild().KEY == null) && (getRightChild().KEY == null)) //O nó retornado é um nó-folha.
{
// Deleta referência para os filhos.
setLeftChild(null);
setRightChild(null);
// Anula a chave.
key = null;
// Zera balanceamento.
balanced = 0;
// Altura com valor de nó nulo.
height = -1;
}
// O nó retornado tem apenas filho a direita.
else if (getLeftChild().KEY == null)
{
// Recebe a chave do filho a direita.
key = getRightChild().KEY;
// Recebe o estado de balanceamento do filho a direita.
balanced = ((AVL)getRightChild()).BALANCED;
// Recebe a altura do filho a direita.
height = getRightChild().HEIGHT;
// Recebe as referências dos filhos do filho a direita.
setRightChild(getRightChild().getRightChild());
setLeftChild(getLeftChild().getLeftChild());
}
// O nó retornado é um nó interno.
else
{
// obtém o filho a esquerda.
AVL leftChild = (AVL)getLeftChild();
// Nó atual recebe a chave do filho mais a direita do filho a esquerda.
// O método deleta a referência do nó folha.
// O método realiza o balanceamento da ávore até o filho.
key = depperRightChild(ref leftChild);
// Realiza balanceamento e atualiza a referência atual.
setThisRef(balance(this));
}
break;
// Caso seja maior, realiza a deleção no filho da direita.
case 1: getRightChild().deleteKey(key);
// Realiza balanceamento e atualiza a referência atual.
setThisRef(balance(this));
break;
// Caso seja menor, realiza a busca no filho da esquerda.
case -1: getLeftChild().deleteKey(key);
// Realiza balanceamento e atualiza a referência atual.
setThisRef(balance(this));
break;
}
}
// Retorna a flag
return(result);
}