static TLDNode *balance(TLDNode *node)
{
int diff;
diff = getDiff(node);
if (diff > 1)
{
if (getDiff(node->left) > 0)
{
node = leftLeftRotation(node);
}
else
{
node = leftRightRotation(node);
}
}
else if (diff < -1)
{
if (getDiff(node->right) > 0)
{
node = rightLeftRotation(node);
}
else
{
node = rightRightRotation(node);
}
}
return node;
}
static TLDNode *leftRightRotation(TLDNode *node)
{
TLDNode *tempTLDnode;
tempTLDnode = node->left;
node->left = rightRightRotation(tempTLDnode);
return leftLeftRotation(node);
}
static TLDNode *rightLeftRotation(TLDNode *node)
{
TLDNode *tempTLDnode;
tempTLDnode =node->right;
node->right = leftLeftRotation(tempTLDnode);
return rightRightRotation(node);
}
bool AVLTree<T>::addNode(T k, T val)
{
bool isSuccess = BSTree<T>::addNode(k, val);
if (isSuccess)
{
NodePointer ptr = searchNode(k);
if (ptr != root)
{
NodePointer preParent = ptr->parent;
if (preParent != root)
{
NodePointer prePreParent = preParent->parent;
if (prePreParent == root)
{
if (getHeight(prePreParent->left) - getHeight(prePreParent->right) == 2)
{
if (ptr == preParent->left)
{
root = leftLeftRotation(prePreParent);
}
else
{
root = leftRightRotation(prePreParent);
}
}
else if (getHeight(prePreParent->right) - getHeight(prePreParent->left) == 2)
{
if (ptr == preParent->left)
{
root = rightLeftRotation(prePreParent);
}
else
{
root = rightRightRotation(prePreParent);
}
}
}
else
{
NodePointer prePrePreParent = prePreParent->parent;
if (getHeight(prePreParent->left) - getHeight(prePreParent->right) == 2)
{
if (prePreParent == prePrePreParent->left)
{
if (ptr == preParent->left)
{
prePrePreParent->left = leftLeftRotation(prePreParent);
}
else
{
prePrePreParent->left = leftRightRotation(prePreParent);
}
}
else
{
if (ptr == preParent->left)
{
prePrePreParent->right = leftLeftRotation(prePreParent);
}
else
{
prePrePreParent->right = leftRightRotation(prePreParent);
}
}
}
else if (getHeight(prePreParent->right) - getHeight(prePreParent->left) == 2)
{
if (prePreParent == prePrePreParent->left)
{
if (ptr == preParent->left)
{
prePrePreParent->left = rightLeftRotation(prePreParent);
}
else
{
prePrePreParent->left = rightRightRotation(prePreParent);
}
}
else
{
if (ptr == preParent->left)
{
prePrePreParent->right = rightLeftRotation(prePreParent);
}
else
{
prePrePreParent->right = rightRightRotation(prePreParent);
}
}
}
}
}
}
}
return isSuccess;
}
Node<T> * AVLTree<T>::rightLeftRotation(Node<T>* k1)
{
k1->right = leftLeftRotation(k1->right);
return rightRightRotation(k1);
}
Node<T> * AVLTree<T>::leftRightRotation(Node<T>* k3)
{
k3->left = rightRightRotation(k3->left);
return leftLeftRotation(k3);
}
bool AVLTree<T>::delNode(T k)
{
bool isSuccess = true;
NodePointer ptr = searchNode(k);
NodePointer preParent = NULL;
if (ptr != NULL)
{
if (ptr == root)
{
BSTree<T>::delNode(k);
// only left left exist
if (getHeight(root->left) - getHeight(root->right) == 2)
{
root = leftLeftRotation(root);
}
}
else
{
NodePointer lNode = NULL, rNode = NULL;
preParent = ptr->parent;
if (preParent == root)
{
BSTree<T>::delNode(k);
lNode = root->left;
rNode = root->right;
if (getHeight(preParent->left) - getHeight(preParent->right) == 2)
{
if (getHeight(lNode->left) >= getHeight(lNode->right))
{
root = leftLeftRotation(preParent);
}
else
{
root = leftRightRotation(preParent);
}
}
else if (getHeight(preParent->right) - getHeight(preParent->left) == 2)
{
if (getHeight(rNode->right) >= getHeight(rNode->left))
{
root = rightRightRotation(preParent);
}
else
{
root = rightLeftRotation(preParent);
}
}
}
else
{
NodePointer prePreParent = NULL;
NodePointer lNode = NULL, rNode = NULL;
BSTree<T>::delNode(k);
// 这里需要递归查找不平衡点,以防止高层结点不平衡而低层结点平衡的情况
NodePointer tmpPtr = findImbalanceNode(preParent);
if (tmpPtr != NULL)
{
if (tmpPtr == root)
{
lNode = tmpPtr->left;
rNode = tmpPtr->right;
if (getHeight(tmpPtr->left) - getHeight(tmpPtr->right) == 2)
{
if (getHeight(lNode->left) >= getHeight(lNode->right))
{
root = leftLeftRotation(tmpPtr);
}
else
{
root = leftRightRotation(tmpPtr);
}
}
else if (getHeight(tmpPtr->right) - getHeight(tmpPtr->left) == 2)
{
if (getHeight(rNode->right) >= getHeight(rNode->left))
{
root = rightRightRotation(tmpPtr);
}
else
{
root = rightLeftRotation(tmpPtr);
}
}
}
else
{
prePreParent = tmpPtr->parent;
lNode = tmpPtr->left;
rNode = tmpPtr->right;
if (getHeight(tmpPtr->left) - getHeight(tmpPtr->right) == 2)
{
if (tmpPtr == prePreParent->left)
{
if (getHeight(lNode->left) >= getHeight(lNode->right))
{
prePreParent->left = leftLeftRotation(tmpPtr);
}
else
{
prePreParent->left = leftRightRotation(tmpPtr);
}
}
else
{
if (getHeight(lNode->left) >= getHeight(lNode->right))
{
prePreParent->right = leftLeftRotation(tmpPtr);
}
else
{
prePreParent->right = leftRightRotation(tmpPtr);
}
}
}
else if (getHeight(tmpPtr->right) - getHeight(tmpPtr->left) == 2)
{
if (tmpPtr == prePreParent->left)
{
if (getHeight(rNode->right) >= getHeight(rNode->left))
{
prePreParent->left = rightRightRotation(tmpPtr);
}
else
{
prePreParent->left = rightLeftRotation(tmpPtr);
}
}
else
{
if (getHeight(rNode->right) >= getHeight(rNode->left))
{
prePreParent->right = rightRightRotation(tmpPtr);
}
else
{
prePreParent->right = rightLeftRotation(tmpPtr);
}
}
}
}
}
}
}
}
else
{
isSuccess = false;
}
return isSuccess;
}
