Height Balanced Binary Tree: A height-balanced binary tree is defined as a binary tree in which the height of the left

and
the right subtree of any node differ by not more than 1. AVL tree, red-black tree are examples of height-balanced trees.

Height Balanced tree

Conditions for Height-Balanced Binary Tree:

Following are the conditions for a height-balanced binary tree:

 The difference between the heights of the left and the right subtree for any node is not more than one.
 The left subtree is balanced.
 The right subtree is balanced.
Note: An empty tree is also height-balanced.

The height balance of a node is calculated as follows:

height balance of node = height of right subtree – height of left subtree

The above formula means that:

 If the right subtree is taller, the height balance of the node will be positive.
 If the left subtree is taller, the balance of the node will be negative.

Advantages of Height-Balanced Binary Tree:

 It will improve the worst-case lookup time at the expense of making a typical case roughly one lookup less.
 As a general rule, a height-balanced tree would work better when the request frequencies across the data set are
more evenly spread,
 It gives better search time complexity.
Disadvantages of Height-Balanced Binary Tree:
 Longer running times for the insert and remove operations.
 Must keep balancing info in each node.
 To find nodes to balance, must go back up in the tree.

AVL Tree Data Structure:

An AVL tree defined as a self-balancing Binary Search Tree (BST) where the difference between heights of left and right
subtrees for any node cannot be more than one.
The difference between the heights of the left subtree and the right subtree for any node is known as the balance factor of
the node.

Example of AVL Trees:

AVL tree

The above tree is AVL because the differences between the heights of left and right subtrees for every node are less than or
equal to 1

Operations on an AVL Tree:

 Insertion
 Deletion
 Searching [It is similar to performing a search in BST]

Rotating the subtrees in an AVL Tree:

An AVL tree may rotate in one of the following four ways to keep itself balanced:

Left Rotation:
When a node is added into the right subtree of the right subtree, if the tree gets out of balance, we do a single left rotation.

Left-Rotation in AVL tree

Right Rotation:
If a node is added to the left subtree of the left subtree, the AVL tree may get out of balance, we do a single right rotation.
 Right Rotation in AVL tree
Left-Right Rotation:
A left-right rotation is a combination in which first left rotation takes place after that right rotation executes.

Left-Right Rotation in AVL tree

Right-Left Rotation:
A right-left rotation is a combination in which first right rotation takes place after that left rotation executes.

Right-Left Rotation in AVL tree

Applications of AVL Tree:

1. It is used to index huge records in a database and also to efficiently search in that.
2. For all types of in-memory collections, including sets and dictionaries, AVL Trees are used.
3. Database applications, where insertions and deletions are less common but frequent data lookups are necessary
4. Software that needs optimized search.
5. It is applied in corporate areas and storyline games.

Advantages of AVL Tree:

1. AVL trees can self-balance themselves.
2. It is surely not skewed.
3. It provides faster lookups than Red-Black Trees
4. Better searching time complexity compared to other trees like binary tree.
5. Height cannot exceed log(N), where, N is the total number of nodes in the tree.
Disadvantages of AVL Tree:

1. It is difficult to implement.
2. It has high constant factors for some of the operations.
3. Less used compared to Red-Black trees.
4. Due to its rather strict balance, AVL trees provide complicated insertion and removal operations as more rotations
are performed.
5. Take more processing for balancing.

B-Tree Data Structure:

A B-tree is a self-balancing tree where all the leaf nodes are at the same level which allows for efficient searching, insertion
and deletion of records.
Because of all the leaf nodes being on the same level, the access time of data is fixed regardless of the size of the data set.

Or

B Tree is a specialized m-way tree that can be widely used for disk access. A B-Tree of order m can have at most m-1 keys and m
children. One of the main reason of using B tree is its capability to store large number of keys in a single node and large key
values by keeping the height of the tree relatively small.

A B tree of order m contains all the properties of an M way tree. In addition, it contains the following properties.
1. Every node in a B-Tree contains at most m children.
2. Every node in a B-Tree except the root node and the leaf node contain at least m/2 children.
3. The root nodes must have at least 2 nodes.
4. All leaf nodes must be at the same level.
It is not necessary that, all the nodes contain the same number of children but, each node must have m/2 number of
nodes.

Characteristics of B-Tree:
B-trees have several important characteristics that make them useful for storing and retrieving large amounts of data
efficiently. Some of the key characteristics of B-trees are:

 Balanced: B-trees are balanced, meaning that all leaf nodes are at the same level. This ensures that the time
required to access data in the tree remains constant, regardless of the size of the data set.
 Self-balancing: B-trees are self-balancing, which means that as new data is inserted or old data is deleted,
the tree automatically adjusts to maintain its balance.
 Multiple keys per node: B-trees allow multiple keys to be stored in each node. This allows for efficient use
of memory and reduces the height of the tree, which in turn reduces the number of disk accesses required to
retrieve data.
 Ordered: B-trees maintain the order of the keys, which makes searching and range queries efficient.
 Efficient for large data sets: B-trees are particularly useful for storing and retrieving large amounts of data,
as they minimize the number of disk accesses required to find a particular piece of data.
Operations:

Searching :
Searching in B Trees is similar to that in Binary search tree. For example, if we search for an item 49 in the following B Tree. The
process will something like following :
1. Compare item 49 with root node 78. since 49 < 78 hence, move to its left sub-tree.
2. Since, 40<49<56, traverse right sub-tree of 40.
3. 49>45, move to right. Compare 49.
4. match found, return.
Searching in a B tree depends upon the height of the tree. The search algorithm takes O(log n) time to search any element in a B
tree.
Inserting:
Insertions are done at the leaf node level. The following algorithm needs to be followed in order to insert an item into B Tree.
1. Traverse the B Tree in order to find the appropriate leaf node at which the node can be inserted.
2. If the leaf node contain less than m-1 keys then insert the element in the increasing order.
3. Else, if the leaf node contains m-1 keys, then follow the following steps.
 Insert the new element in the increasing order of elements.
 Split the node into the two nodes at the median.
 Push the median element upto its parent node.
 If the parent node also contain m-1 number of keys, then split it too by following the same steps.
Example:
Insert the node 8 into the B Tree of order 5 shown in the following image.

8 will be inserted to the right of 5, therefore insert 8.

The node, now contain 5 keys which is greater than (5 -1 = 4 ) keys. Therefore split the node from the median i.e. 8 and push it
up to its parent node shown as follows.

Deletion:
Deletion is also performed at the leaf nodes. The node which is to be deleted can either be a leaf node or an internal node.
Following algorithm needs to be followed in order to delete a node from a B tree.

1. Locate the leaf node.

2. If there are more than m/2 keys in the leaf node then delete the desired key from the node.
 3. If the leaf node doesn't contain m/2 keys then complete the keys by taking the element from eight or left sibling.
 If the left sibling contains more than m/2 elements then push its largest element up to its parent and move the
intervening element down to the node where the key is deleted.
 If the right sibling contains more than m/2 elements then push its smallest element up to the parent and move
intervening element down to the node where the key is deleted.
4. If neither of the sibling contain more than m/2 elements then create a new leaf node by joining two leaf nodes and
the intervening element of the parent node.
5. If parent is left with less than m/2 nodes then, apply the above process on the parent too.

If the the node which is to be deleted is an internal node, then replace the node with its in-order successor or predecessor.
Since, successor or predecessor will always be on the leaf node hence, the process will be similar as the node is being deleted
from the leaf node.

Example 1

Delete the node 53 from the B Tree of order 5 shown in the following figure.

53 is present in the right child of element 49. Delete it.

Now, 57 is the only element which is left in the node, the minimum number of elements that must be present in a B tree of
order 5, is 2. it is less than that, the elements in its left and right sub-tree are also not sufficient therefore, merge it with the left
sibling and intervening element of parent i.e. 49.

The final B tree is shown as follows.