Insertion in Splay Tree in C++

Splay Trees is a type of binary search tree. It has a unique feature in which they dynamically alter their structure based on recent access history. This ability makes them particularly efficient for certain operations, and one such operation is the insertion of nodes. In this article, we will discuss the insertion of nodes in a splay tree in C++.

Before delving into insertion, let's briefly revisit the characteristics of a Splay Tree. These trees are binary search trees that prioritize the most recently accessed element by moving it to the root. This process, known as "splaying", involves a series of rotations and rearrangements.

Inserting a node into a Splay Tree involves two main steps:

Normal Binary Search Tree Insertion: Initially, the new node is inserted using the conventional binary search tree approach. It entails finding the appropriate position based on the node's value and adding it as a leaf.

Splaying: Post the standard insertion, the newly inserted node undergoes a splaying process, ensuring it becomes the root. This dynamic adjustment is vital for maintaining the tree's adaptability based on access history.

Example:

Let's take a closer look at the C++ code that brings this process to life.

#include <iostream>
 
// Node structure for Splay Tree
struct Node {
    int key;
    Node* left, *right;
};
 
// Function to perform right rotation
Node* rightRotate(Node* x) {
    Node* y = x->left;
    x->left = y->right;
    y->right = x;
    return y;
}
 
// Function to perform left rotation
Node* leftRotate(Node* x) {
    Node* y = x->right;
    x->right = y->left;
    y->left = x;
    return y;
}
 
// Splay operation to move the recently accessed node to the root
Node* splay(Node* root, int key) {
    if (!root || root->key == key)
        return root;
 
    // Key lies in the left subtree
    if (key < root->key) {
        // Key is not present in the tree
        if (!root->left)
            return root;
 
        // Zig-Zig (Left Left)
        if (key < root->left->key) {
            root->left->left = splay(root->left->left, key);
            root = rightRotate(root);
        }
        // Zig-Zag (Left Right)
        else if (key > root->left->key) {
            root->left->right = splay(root->left->right, key);
            if (root->left->right)
                root->left = leftRotate(root->left);
        }
 
        // Perform the second rotation for Zig-Zag and Zig-Zig
        return (root->left) ? rightRotate(root) : root;
    }
    // Key lies in the right subtree
    else {
        // Key is not present in the tree
        if (!root->right)
            return root;
 
        // Zag-Zag (Right Right)
        if (key > root->right->key) {
            root->right->right = splay(root->right->right, key);
            root = leftRotate(root);
        }
        // Zag-Zig (Right Left)
        else if (key < root->right->key) {
            root->right->left = splay(root->right->left, key);
            if (root->right->left)
                root->right = rightRotate(root->right);
        }
 
        // Perform the second rotation for Zag-Zig and Zag-Zag
        return (root->right) ? leftRotate(root) : root;
    }
}
 
// Function to insert a key into the Splay Tree
Node* insert(Node* root, int key) {
    // If the tree is empty, create a new node
    if (!root)
        return new Node{ key, nullptr, nullptr };
 
    // Perform a standard BST insert
    if (key < root->key)
        root->left = insert(root->left, key);
    else if (key > root->key)
        root->right = insert(root->right, key);
    else
        return root; // Duplicate keys are not allowed
 
    // Perform the splay operation on the newly inserted node
    return splay(root, key);
}
 
// Function to print the in-order traversal of the tree
void inOrder(Node* root) {
    if (root) {
        inOrder(root->left);
        std::cout << root->key << " ";
        inOrder(root->right);
    }
}
 
int main() {
    Node* root = nullptr;
 
    // Insert elements into the Splay Tree
    root = insert(root, 10);
    root = insert(root, 5);
    root = insert(root, 15);
    root = insert(root, 2);
    root = insert(root, 8);
 
    std::cout << "In-order traversal of the Splay Tree: ";
    inOrder(root);
 
    return 0;
}

Output:

In-order traversal of the Splay Tree: 2 5 8 10 15

Explanation:

The provided C++ code encapsulates the logic behind Splay Tree insertion. It includes functions for right and left rotations, the splaying operation, and the insertion process itself. The main function demonstrates the insertion of a sequence of elements (10, 5, 15, 2, 8) into the Splay Tree.

Conclusion:

Splay Trees present a captivating approach to binary search trees, dynamically adjusting their structure based on recent access patterns. As exemplified through the C++ code, the insertion operation seamlessly integrates standard binary search tree insertion with a subsequent splaying operation, ensuring the tree's self-adjusting property.

A solid grasp of Splay Trees and their insertion operation is crucial for effectively utilizing their advantages in applications where dynamic adaptability is paramount.

Next Topickruskal's algorithm in C++

← prev next →