Introduction of B+ Tree

A B+ Tree is an advanced data structure used in database systems and file systems to maintain sorted data for fast retrieval, especially from disk. It is an extended version of the B Tree, where all actual data is stored only in the leaf nodes, while internal nodes contain only keys for navigation.

Components of B+ Tree

• Leaf nodes store all the key values and pointers to the actual data.
• Internal nodes store only the keys that guide searches.
• All leaf nodes are linked together, supporting efficient sequential and range queries.

This structure makes the B+ Tree balanced, disk-efficient, and ideal for database indexing.

Features of B+ Trees

• Balanced: Auto-adjusts when data is added or removed, keeping search time efficient.
• Multi-level: Has a root, internal nodes, and leaf nodes (which store the data).
• Ordered: Maintains sorted keys, making range queries easy.
• High Fan-out: Each node has many children, keeping the tree short and fast.
• Cache-friendly: Works well with memory caches for better speed.
• Disk-efficient: Ideal for disk storage due to fast data access.

How B+ Trees Work

The Structure of the Internal Nodes of a B+ Tree of Order 'a' is as Follows

• Each internal node is of the form: <P₁, K₁, P₂, K₂, ....., P_c-1, K_c-1, P_c> where c <= a and each P_i is a tree pointer (i.e points to another node of the tree) and, each K_i is a key-value (see diagram-I for reference).
• Every internal node has : K₁ < K₂ < .... < K_c-1
• For each search field value 'X' in the sub-tree pointed at by P_i, the following condition holds: K_i-1 < X <= K_i, for 1 < I < c and, K_i-1 < X, for i = c (See diagram I for reference)
• Each internal node has at most 'a' tree pointers.
• The root node has, at least two tree pointers, while the other internal nodes have at least tree pointers each.
• If an internal node has 'c' pointers, c <= a, then it has 'c - 1' key values.

 The Structure of the Leaf Nodes of a B+ Tree of Order 'b' is as Follows

• Each leaf node is of the form: <<K₁, D₁>, <K₂, D₂>, ....., <K_c-1, D_c-1>, P_next> where c <= b and each D_i is a data pointer (i.e points to actual record in the disk whose key value is K_i or to a disk file block containing that record) and, each K_i is a key value and, P_next points to next leaf node in the B+ tree (see diagram II for reference).
• Every leaf node has : K₁ < K₂ < .... < K_c-1, c <= b
• Each leaf node has at least values.
• All leaf nodes are at the same level.

In the below diagram, we can see that using the P_next pointer it is viable to traverse all the leaf nodes, just like a linked list, thereby achieving ordered access to the records stored in the disk. 

Searching a Record in B+ Trees

To search for a key:

1. Start at the root node
2. Navigate through internal nodes based on key comparisons
3. Reach the appropriate leaf node
4. If the key exists, return the data; otherwise, report "record not found"

Example: In the image below, in order to search for 58, traverse the root → internal node → reach the correct leaf node that contains 58 (if it exists).

Insertion in B+ Trees

Insertion in B+ Trees is done in three steps:

1. Navigate to the correct leaf node
2. Insert the new key in sorted order

3. If overflow occurs:

• Split the leaf node
• Push the middle key to the parent
• This process may propagate up to the root

For more, refer to Insertion in a B+ Trees.

Deletion in B+Trees

Deletion involves:

1. Finding and removing the key from the appropriate leaf node

2. Rebalancing the tree to maintain B+ Tree properties:

• Borrowing keys from siblings or
• Merging nodes if necessary

For more, refer to Deletion in B+ Trees.

Difference Between B+ Tree and B Tree

Some differences between B+ Tree and B Tree are stated below.

Advantages

• A B+ tree with 'l' levels can store more entries in its internal nodes compared to a B-tree having the same 'l' levels. This accentuates the significant improvement made to the search time for any given key. Having lesser levels and the presence of P_next pointers imply that the B+ trees is very quick and efficient in accessing records from disks. 
• Data stored in a B+ tree can be accessed both sequentially and directly.
• It takes an equal number of disk accesses to fetch records.
• B+trees have redundant search keys, and storing search keys repeatedly is not possible. 

Disadvantages

• Slower exact match: Data is always in leaf nodes, increasing search path.
• More disk access: Requires reaching the leaf even for a single record.
• Complex updates: Insertion and deletion are more complex.
• Extra space: Leaf node links need additional pointers.