void balanceAvl(struct node **root){
if(*root == NULL)
return;
int height_diff = 0;
height_diff = height_difference(*root);
if((*root)->lptr)
balanceAvl(&(*root)->lptr);
else
balanceAvl(&(*root)->rptr);
if(height_diff >= 2){
if(height_difference((*root)->lptr) >= 1)
*root = leftLeftRotate(*root);
else
*root = leftRightRotate(*root);
} else if(height_diff <= -2){
if(height_difference((*root)->rptr) <= -1)
*root = rightRightRotate(*root);
else
*root = rightLeftRotate(*root);
} else{
*root = *root;
}
}
/**
* root
* / root
* v / root
* 5 v /
* / \ 5 v
* 1 10 ---> / \ ---> 8
* / \ 3 8 / \
* 8 15 / \ 5 10
* / 1 10 / \ \
* 3 \ 1 3 15
* 15
*
*
*
*
*
*/
void test_rightLeftRotate_rotate_6_elements_with_left_grand_left_child(void){
setNode(&node1, NULL, NULL, 'b');
setNode(&node3, NULL, NULL, 'b');
setNode(&node8, &node3, NULL, 'b');
setNode(&node5, &node1, &node10, 'b');
setNode(&node15, NULL, NULL, 'b');
setNode(&node10, &node8, &node15, 'b');
Node *root = &node5;
rightLeftRotate(&root);
TEST_ASSERT_EQUAL_PTR(node1.left, NULL);
TEST_ASSERT_EQUAL_PTR(node1.right, NULL);
TEST_ASSERT_EQUAL_PTR(node3.left, NULL);
TEST_ASSERT_EQUAL_PTR(node3.right, NULL);
TEST_ASSERT_EQUAL_PTR(node5.left, &node1);
TEST_ASSERT_EQUAL_PTR(node5.right, &node3);
TEST_ASSERT_EQUAL_PTR(node8.left, &node5);
TEST_ASSERT_EQUAL_PTR(node8.right, &node10);
TEST_ASSERT_EQUAL_PTR(node10.left, NULL);
TEST_ASSERT_EQUAL_PTR(node10.right, &node15);
TEST_ASSERT_EQUAL_PTR(node15.left, NULL);
TEST_ASSERT_EQUAL_PTR(node15.right, NULL);
TEST_ASSERT_EQUAL_PTR(root, &node8);
}
void restructureUnBalanceTreeWithoutColourFlopping( Node **rootPtr){
Node *root = *rootPtr;
if( root->left && !(root->right) ){
if( root->left->left && !(root->left->right) )
rightRotate(&(*rootPtr));
else if( root->left->right && !(root->left->left) )
leftRightRotate(&(*rootPtr));
}
else if(root->right && !(root->left) ){
if( root->right->right && !(root->right->left) )
leftRotate(&(*rootPtr));
else if( root->right->left && !(root->right->right) )
rightLeftRotate(&(*rootPtr));
}
}
/**
* root
* / root
* v / root
* 5 v /
* \ 5 v
* 10 ---> \ ---> 7
* / 7 / \
* 7 \ 5 10
* 10
*
*
*/
void test_rightLeftRotate_rotate_3_elements(void){
setNode(&node7, NULL, NULL, 'b');
setNode(&node5, NULL, &node10, 'b');
setNode(&node10, &node7, NULL, 'b');
Node *root = &node5;
rightLeftRotate(&root);
TEST_ASSERT_EQUAL_PTR(node5.left, NULL);
TEST_ASSERT_EQUAL_PTR(node5.right, NULL);
TEST_ASSERT_EQUAL_PTR(node7.left, &node5);
TEST_ASSERT_EQUAL_PTR(node7.right, &node10);
TEST_ASSERT_EQUAL_PTR(node10.left, NULL);
TEST_ASSERT_EQUAL_PTR(node10.right, NULL);
TEST_ASSERT_EQUAL_PTR(root, &node7);
}
void solveAddViolationForNewNodeMoreThan(Node **nodePtr)
{
if((*nodePtr)->right->right != NULL) {
if(((*nodePtr)->right->color == 'r' && (*nodePtr)->right->right->color == 'r' && (*nodePtr)->left == NULL) ||
((*nodePtr)->right->color == 'r' && (*nodePtr)->right->right->color == 'r' && (*nodePtr)->left->color == 'b')){
leftRotate(&(*nodePtr));
(*nodePtr)->left->color = 'r';
}
} else if ((*nodePtr)->right->left != NULL) {
if(((*nodePtr)->right->color == 'r' && (*nodePtr)->right->left->color == 'r' && (*nodePtr)->left == NULL) ||
((*nodePtr)->right->color == 'r' && (*nodePtr)->right->left->color == 'r' && (*nodePtr)->left->color == 'b')){
rightLeftRotate(&(*nodePtr));
(*nodePtr)->left->color = 'r';
}
}
}
void restructureUnBalanceTree( Node **rootPtr){
Node *root = *rootPtr;
if( root->left && !(root->right) ){
if( root->left->left && !(root->left->right) ){
rightRotate(&(*rootPtr));
(*rootPtr)->right->color = 'r';
}else if( root->left->right && !(root->left->left) ){
leftRightRotate(&(*rootPtr));
(*rootPtr)->right->color = 'r';
}
}
else if(root->right && !(root->left) ){
if( root->right->right && !(root->right->left) ){
leftRotate(&(*rootPtr));
(*rootPtr)->left->color = 'r';
}else if( root->right->left && !(root->right->right) ){
rightLeftRotate(&(*rootPtr));
(*rootPtr)->left->color = 'r';
}
}
}
AVLTree rotate(AVLTree adjustNode){
enum RoateType type = getRoateType(adjustNode);
AVLTree newNode = adjustNode;
switch (type) {
case RotateLeft:
newNode = leftRotate(adjustNode);
break;
case RotateRight:
newNode = rightRotate(adjustNode);
break;
case RotateLeftRight:
newNode = leftRightRotate(adjustNode);
break;
case RotateRightLeft:
newNode = rightLeftRotate(adjustNode);
break;
default:
break;
}
return newNode;
}
