Chapter 6 AVL Search Trees - Lakehead Universityccc.cs.lakeheadu.ca/cs2412/slides/cs2412-s6.pdf ·...

CS 2412 Data Structures

Chapter 6

AVL Search Trees

The efficiency of binary search tree depends on the shape of the

tree.

• If an ordered or almost ordered sequence of data are inserted to

a binary tree, then the search is not efficient. (O(n)).

• If the inserted data is random, the tree is more efficient.

• An idea binary search tree is a “balanced” tree, for that the

search complexity is O(log n).

Data Structure 2016 R. Wei 2

Definition

An AVL tree is a binary tree that either is empty or consists of two

AVL subtrees, TL and TR, whose heights differ by no more than 1.

Let HL, HR denote the height of TL, TR respectively, then

|HL −HR| ≤ 1.

An AVL tree is also know as a height-balanced binary search tree.

An AVL tree with HL = HR + 1 is called left high (LH), with

HL = HR − 1 is called right high (RH), and with HL = HR is

called equal (or even) high (EH).


Balancing trees

When a node is inserted into a tree or deleted from a balanced tree,

the resulting tree may be unbalanced. Some rotating methods are

used in AVL to balance the tree.

1. Left of left: a subtree of a tree that is left high has also become

left high.

2. Right of right: a subtree of a tree that is right high has also

become right high.

3. Right of left: a subtree of a tree that is left high has become

right high.

4. Left of right: a subtree of a tree that is right high has become

left high.


Left of left

One simple case is that the lowest subtree is not balanced. This

case needs a rotation to right.

Another case is that the subtree is balanced, but the whole tree is

not balanced. In this case, we need to rotate the root to right. And

we also need to move the right subtree of the subtree as a left

subtree of the old root.

Right of right is similar.


Right of left

Suppose the root is left high and the left tree is right high. To

balance this tree, we need first to do a left rotation and then do a

right rotation making the left node the new root.

Suppose an internal node is left high and its left subtree is right

high. First rotate the left subtree of the node. Now the node in a

left of left situation, and we do the right rotation as the left of left

case.

Left of right is similar.


Algorithms for AVL

AVL tree is a special kind BST. So some algorithms for BST can be

used for AVL: such as search, retrieval, traversal etc.

The insertion and deletion algorithm should be changed since the

balance need to be checked constantly. Before insertion, AVL tree

is balance. After inserting a node, a balance check may required.

• If the original tree is EH, then no rotation is needed.

• If the original tree is LH and the node is inserted to right

subtree, or if the original tree is RH and the node is inserted to

left subtree, then no rotation is needed.

• Otherwise, we need to check if the resulting tree is balanced.


If the root is LH and a node has been inserted to the left subtree

which is now taller (higher). Then the following algorithm is called.

The algorithm for right balance is similar to left balance (mirrors of

each other).


rotateRight: Make left subtree new root and the right subtree of

the left subtree the left subtree of the original root.


Rotate left is similar.


Deletion

Deletion is similar to that in BST. First find out the node needs to

be delete. If the node is a leaf, then simply delete it. If the node is

not a leaf, then we need to find out a node which can replace the

deleting node.

Similar to insertion of AVL, we also need to check balance after

deleting a node. For example, if the deleted node is at left subtree,

and the original tree is RH, then we need to check if the left tree is

shorter after deletion.


Delete left balance is similar.


Adjusting the balance factor

After an insertion, we need to adjust the balance factors for the

nodes.

• If the root was EH before an insert, it is now high on the side

in witch the insert was made.

• If an insert was in the shorter subtree of a tree that was not

EH, the root is now EH.

• If an insert was in the higher subtree of a tree that was not

EH, the root must be rotated.

The balance factor need to adjust after deletion in a similar way.


Implement AVL in C

#define LH +1 // Left High

#define EH 0 // Even High

#define RH -1 // Right High

typedef struct node

{

void* dataPtr;

struct node* left;

int bal; //LH of EH or RH

struct node* right;

} NODE;

typedef struct

{

int count;

int (*compare) (void* argu1, void* argu2);

NODE* root;

} AVL_TREE;


AVL_TREE* AVL_Create

(int (*compare) (void* argu1, void* argu2))

{

AVL_TREE* tree;

tree = (AVL_TREE*) malloc (sizeof (AVL_TREE));

if (tree)

{

tree->root = NULL;

tree->count = 0;

tree->compare = compare;

} // if

return tree;

} // AVL_Create


bool AVL_Insert (AVL_TREE* tree, void* dataInPtr)

{

NODE* newPtr;

bool forTaller;

newPtr = (NODE*)malloc(sizeof(NODE));

if (!newPtr)

return false;

newPtr->bal = EH;

newPtr->right = NULL;

newPtr->left = NULL;

newPtr->dataPtr = dataInPtr;

tree->root = _insert(tree, tree->root,

newPtr, &forTaller);

(tree->count)++;

return true;

} // AVL_Insert


NODE* _insert (AVL_TREE* tree, NODE* root,

NODE* newPtr, bool* taller)

{

if (!root)

{

root = newPtr;

*taller = true;

return root;

} // if NULL tree

if (tree->compare(newPtr->dataPtr,

root->dataPtr) < 0)

{

root->left = _insert(tree, root->left,

newPtr, taller);

if (*taller)

switch (root->bal)

{

case LH: // Was left high--rotate


root = insLeftBal (root, taller);

break;

case EH: // Was balanced--now LH

root->bal = LH;

break;

case RH: // Was right high--now EH

root->bal = EH;

*taller = false;

break;

} // switch

return root;

} // new < node

else

{

root->right = _insert (tree, root->right,

newPtr, taller);

if (*taller)

switch (root->bal)


{

case LH: // Was left high--now EH

root->bal = EH;

*taller = false;

break;

case EH: // Was balanced--now RH

root->bal = RH;

break;

case RH: // Was right high--rotate

root = insRightBal

(root, taller);

break;

} // switch

return root;

} // else new data >= root data

return root;

} // _insert


NODE* insLeftBal (NODE* root, bool* taller)

{

NODE* rightTree;

NODE* leftTree;

leftTree = root->left;

switch (leftTree->bal)

{

case LH: // Left High--Rotate Right

root->bal = EH;

leftTree->bal = EH;

root = rotateRight (root);

*taller = false;

break;

case EH: // This is an error

printf ("\n\aError in insLeftBal\n");

exit (100);

case RH: // Right High-Requires double

rightTree = leftTree->right;


switch (rightTree->bal)

{

case LH: root->bal = RH;

leftTree->bal = EH;

break;

case EH: root->bal = EH;

leftTree->bal = EH;

break;

case RH: root->bal = EH;

leftTree->bal = LH;

break;

} // switch rightTree

rightTree->bal = EH;

root->left = rotateLeft (leftTree);


*taller = false;

} // switch

return root; }


NODE* rotateLeft (NODE* root)

{

NODE* tempPtr;

tempPtr = root->right;

root->right = tempPtr->left;

tempPtr->left = root;

return tempPtr;

} // rotateLeft

The program for rotateRight is similar.


bool AVL_Delete (AVL_TREE* tree, void* dltKey)

{

bool shorter;

bool success;

NODE* newRoot;

newRoot = _delete (tree, tree->root, dltKey,

&shorter, &success);

if (success)

{

tree->root = newRoot;

(tree->count)--;

return true;

} // if

else

return false;

} // AVL_Delete


NODE* _delete (AVL_TREE* tree, NODE* root,

void* dltKey, bool* shorter,

bool* success)

{

NODE* dltPtr;

NODE* exchPtr;

NODE* newRoot;

if (!root)

{

*shorter = false;

*success = false;

return NULL;

} // if

if (tree->compare(dltKey, root->dataPtr) < 0)

{

root->left = _delete (tree,

root->left, dltKey,

shorter, success);


if (*shorter)

root = dltRightBal (root, shorter);

} // if less

else if (tree->compare(dltKey, root->dataPtr) > 0)

{

root->right = _delete (tree,

root->right, dltKey,

shorter, success);

if (*shorter)

root = dltLeftBal (root, shorter);

} // if greater

else

{

dltPtr = root;

if (!root->right)

// Only left subtree

{

newRoot = root->left;


*success = true;

*shorter = true;

free (dltPtr);

return newRoot; // base case

} // if true

else

if (!root->left)

{

newRoot = root->right;

*success = true;

*shorter = true;

free (dltPtr);

return newRoot; // base case

} // if

else

{

exchPtr = root->left;

while (exchPtr->right)


exchPtr = exchPtr->right;

root->dataPtr = exchPtr->dataPtr;

root->left = _delete (tree,

root->left, exchPtr->dataPtr,

shorter, success);

if (*shorter)

root = dltRightBal (root, shorter);

} // else

} // equal node

return root;

} // _delete


NODE* dltRightBal (NODE* root, bool* shorter)

{

NODE* rightTree;

NODE* leftTree;

switch (root->bal)

{

case LH: // Deleted Left--Now balanced

root->bal = EH;

break;

case EH: // Now Right high

root->bal = RH;

*shorter = false;

break;

case RH: // Right High - Rotate Left

rightTree = root->right;

if (rightTree ->bal == LH)

{letTree = rightTree->left;

switch (leftTree->bal)


{

case LH: rightTree->bal = RH;

root->bal = EH;

break;



break;

case RH: root->bal = LH;


break;

} // switch

leftTree->bal = EH;

root->right =

rotateRight (rightTree);

root = rotateLeft (root);

} // if rightTree->bal == LH

else

{


switch (rightTree->bal)

{

case LH:



break;

case EH: root->bal = RH;

rightTree->bal = LH;

*shorter = false;

break;

} // switch rightTree->bal

root = rotateLeft (root);

} // else

} // switch

return root;

} // dltRightBal


void* AVL_Retrieve (AVL_TREE* tree, void* keyPtr)

{

if (tree->root)

return _retrieve (tree, keyPtr, tree->root);

else

return NULL;

} // AVL_Retrieve


void* _retrieve (AVL_TREE* tree,

void* keyPtr, NODE* root)

{

if (root)

{

if (tree->compare(keyPtr, root->dataPtr) < 0)

return _retrieve(tree, keyPtr, root->left);

else if (tree->compare(keyPtr, root->dataPtr) > 0)

return _retrieve(tree, keyPtr, root->right);

else

return root->dataPtr;

} // if root

else

return NULL;

} // _retrieve


void AVL_Traverse (AVL_TREE* tree,

void (*process) (void* dataPtr))

{

// Statements

_traversal (tree->root, process);

return;

} // end AVL_Traverse


void _traversal (NODE* root,

void (*process) (void* dataPtr))

{

// Statements

if (root)

{

_traversal (root->left, process);

process (root->dataPtr);

_traversal (root->right, process);

} // if

return;

} // _traversal


AVL_TREE* AVL_Destroy (AVL_TREE* tree)

{

// Statements

if (tree)

_destroy (tree->root);

// All nodes deleted. Free structure

free (tree);

return NULL;

} // AVL_Destroy


void _destroy (NODE* root)

{

// Statements

if (root)

{

_destroy (root->left);

free (root->dataPtr);

_destroy (root->right);

free (root);

} // if

return;

} // _destroy


NODE* insRightBal (NODE* root, bool* taller)

{

NODE *rightTree;

NODE *leftTree;

rightTree = root->right;

switch (rightTree->bal )

{

case LH: // Left High - Requires double rotation:

leftTree = rightTree-> left;

switch (leftTree->bal )

{

case RH: root->bal = LH;


break;



break;

case LH: root->bal = EH;

rightTree->bal = RH;

break;

} // switch


leftTree->bal = EH;

root->right = rotateRight (rightTree );

root = rotateLeft (root );

*taller = false;

break;

case EH: printf( "\n\a\aError in rightBalance\n" );

break;

root->bal = EH;

taller = false;

break;



root = rotateLeft ( root );

*taller = false;

break;

} // switch

return root;

} // insRightBal


NODE* dltLeftBal ( NODE* root, bool* smaller )

{

NODE *rightTree;

NODE *leftTree;

switch ( root->bal )

{


break;

case EH: root->bal = LH;

*smaller = false;

break;

case LH: leftTree = root->left;

switch ( leftTree->bal )

{

case LH:

case EH: if ( leftTree->bal == EH )

{

root->bal = LH;


leftTree->bal = RH;

*smaller = false;

}

else

{

root->bal = EH;

leftTree->bal = EH;

}


break;

case RH: // Double Rotation

rightTree = leftTree->right;

switch ( rightTree->bal )

{

case LH: root->bal = RH;

leftTree->bal = EH;

break;



leftTree->bal = EH;

break;


leftTree->bal = LH;

break;

} // switch


root->left = rotateLeft (leftTree);


break;

} // switch : leftTree->bal

} // switch : root->bal

return root;

} // dltLeftBalance


void AVL_Print (AVL_TREE* tree);

void _print (NODE* root, int level);

void AVL_Print (AVL_TREE* tree)

{

void _print (NODE* root, int level);

_print (tree->root, 0);

return;

} // AVL_PRINT

void _print (NODE* root, int level)

{

int i;

if ( root )

{

_print ( root->right, level + 1 );


printf( "bal %3d: Level: %3d", root->bal, level );

for (i = 0; i <= level; i++ )

printf ("...." );

printf( "%3d", *(int *)(root->dataPtr) );

if (root->bal == LH)

printf( " (LH)\n");

else if (root->bal == RH)

printf( " (RH)\n");

else

printf( " (EH)\n");

_print ( root->left, level + 1 );

} // if

return;

} // print *


Example Count words

Uses an AVL tree to count the number of times each words in a

document. For each time a word is read, search the tree to see if

the tree has an node containing the word. If the word is found,

then increase the count of the word. Otherwise insert a new node

containing the word.

We want to use the ADT AVL C program introduced previously.


First we define the data of the node as below.

typedef struct

{

char word[51]; // One word

int count;

} DATA;

Then we construct the system. We can use a structured method to

construct the system, i.e., construct it top-down. So the main

function is simple, which contains main steps. Then for each step,

we give more detailed construction.


int main (void)

{

AVL_TREE* wordList;

printf("Start count words in document\n");

wordList = AVL_Create (compareWords);

buildList (wordList);

printList (wordList);

printf("End count words\n");

return 0;

} // main


void buildList (AVL_TREE* wordList)

{

char fileName[25];

FILE* fpWords;

bool success;

DATA* aWord;

DATA newWord;

printf("Enter name of file to be processed: ");

scanf ("%24s", fileName);

fpWords = fopen (fileName, "r");

if (!fpWords)

{

printf("%-s could not be opened\a\n",fileName);

printf("Please verify name and try again.\n");

exit (100);

} // !fpWords


while (getWord (&newWord, fpWords))

{

aWord = AVL_Retrieve(wordList, &(newWord));

if (aWord)

(aWord->count)++;

else

{

aWord = (DATA*) malloc (sizeof (DATA));

if (!aWord)

{

printf("Error 120 in buildList\n");

exit (120);

} // if

*aWord = newWord;

aWord->count = 1;

success = AVL_Insert (wordList, aWord);


if (!success)

{

printf("Error 121 in buildList\a\n");

exit (121);

} // if overflow test

} // else

} // while

printf("End AVL Tree\n");

return;

} // buildList


bool getWord (DATA* aWord, FILE* fpWords)

{

char strIn[51];

int ioResult;

int lastChar;

ioResult = fscanf(fpWords, "%50s", strIn);

if (ioResult != 1)

return false;

// Copy and remove punctuation at end of word.

strcpy (aWord->word, strIn);

lastChar = strlen(aWord->word) - 1;

if (ispunct(aWord->word[lastChar]))

aWord->word[lastChar] = ’\0’;

return true;

} // getWord


int compareWords (void* arguPtr, void* listPtr)

{

DATA arguValue;

DATA listValue;

arguValue = *(DATA*)arguPtr;

listValue = *(DATA*)listPtr;

return (strcmp(arguValue.word, listValue.word));

} // compare


void printList (AVL_TREE* wordList)

{

printf("\nWords found in list\n");

AVL_Traverse (wordList, printWord);

printf("\nEnd of word list\n");

return;

} // printList

void printWord (void* aWord)

{

// Statements

printf("%-25s %3d\n",

((DATA*)aWord)->word, ((DATA*)aWord)->count);

return;

} // printWord


Chapter 6 AVL Search Trees - Lakehead Universityccc.cs.lakeheadu.ca/cs2412/slides/cs2412-s6.pdf ·...

Documents

Transcript of Chapter 6 AVL Search Trees - Lakehead Universityccc.cs.lakeheadu.ca/cs2412/slides/cs2412-s6.pdf ·...