# What Is 2 Tree in Data Structure?

//

Heather Bennett

A 2-Tree, also known as a 2-3 Tree, is a type of data structure used in computer science and information systems. It is a balanced search tree that maintains sorted data and allows efficient searching, insertion, and deletion operations.

## Structure of a 2-Tree

A 2-Tree consists of nodes that can have either one or two keys. Each node can have at most two children. The keys in each node are arranged in ascending order from left to right.

There are three types of nodes in a 2-Tree:

• Leaf Nodes: Leaf nodes are the bottommost nodes in the tree which contain the actual data elements. They do not have any children.
• Two-key Nodes: Two-key nodes have two keys and three pointers to their children.
• Three-key Nodes: Three-key nodes have three keys and four pointers to their children.

## Insertion Operation

The insertion operation in a 2-Tree is performed by first finding the appropriate leaf node where the new key should be inserted. If the leaf node has room for an additional key, it is simply inserted there while maintaining the sorted order.

If the leaf node already has two keys, it needs to be split into two separate leaf nodes. The middle key is promoted to its parent node while keeping the smaller key on the left and the larger key on the right. This process continues recursively until all parent nodes are adjusted accordingly.

### Example:

To illustrate the insertion operation, let’s consider an empty 2-Tree where we insert keys: 10, 20, 30, 40, 50, and 60.

Step 1: Inserting key 10:

The tree becomes:

```          [10]
```

Step 2: Inserting key 20:

The tree becomes:

```          [10,20]
```

Step 3: Inserting key 30:

The tree becomes:

```       [10,20,30]
```

Step 4: Inserting key 40:

The tree becomes:

```     [20]
/     \
[10]   [30,40]
```

Step 5: Inserting key 50:

The tree becomes:

```      [20,40]
/    |    \
[10] [30] [50]
```

Step 6: Inserting key 60:

The tree becomes:

```      [20,40]
/    |    \
[10] [30] [50,60]
```

## Deletion Operation

The deletion operation in a 2-Tree is performed by first finding the node containing the key to be deleted. If the node is a leaf node and has more than one key, the key is simply removed from the node.

If the node is a leaf node and has only one key left after deletion, we check its siblings. If any of its siblings has more than one key, we borrow a key from the sibling to maintain balance. Otherwise, we merge the node with one of its siblings.

If the node is an internal node, we find the predecessor or successor key in the tree and replace the key to be deleted with it. The predecessor or successor key is then deleted from its original location, which is a leaf node.

### Example:

To illustrate the deletion operation, let’s consider a 2-Tree with keys: 10, 20, 30, 40, 50, and 60. We will delete keys: 30 and 50.

Step 1: Deleting key 30:

The tree becomes:

```      [20]
/    |    \
[10] [40] [50,60]
```

Step 2: Deleting key 50:

The tree becomes:

```      [20]
/    |    \
[10] [40]     [60]
```

## Conclusion

A 2-Tree is a balanced search tree that maintains sorted data efficiently. Its structure ensures that all leaf nodes are at the same level and guarantees efficient search operations.

The insertion and deletion operations in a 2-Tree maintain balance by splitting or merging nodes as required. Understanding the structure and operations of a 2-Tree can greatly contribute to efficient data management in various applications.