Splay Tree - Problem

Implement a Splay Tree data structure with the three essential rotation operations: zig, zig-zig, and zig-zag. A splay tree is a self-adjusting binary search tree where frequently accessed elements are moved closer to the root through splaying operations, optimizing future access times.

Your implementation should support search, insert, and delete operations. When any node is accessed, it should be splayed to the root using the appropriate rotation sequence based on its position relative to its parent and grandparent.

The splaying operations are:

Zig: Single rotation when the node is a direct child of root
Zig-Zig: Double rotation when node and parent are both left children or both right children
Zig-Zag: Double rotation when node and parent are on opposite sides (left-right or right-left)

Return the inorder traversal of the tree after performing all operations.

Input & Output

Example 1 — Basic Insert Operations

$ Input: operations = [["insert",5],["insert",3],["insert",7],["insert",1]]

› Output: [1,3,5,7]

💡 Note: Insert nodes 5, 3, 7, 1 into splay tree. After each insert, the newly inserted node is splayed to root. Final inorder traversal gives sorted sequence.

Example 2 — Insert and Search

$ Input: operations = [["insert",10],["insert",5],["search",5],["insert",15]]

› Output: [5,10,15]

💡 Note: Insert 10, then 5. Search for 5 splays it to root. Insert 15. Final tree has 5 at root with 10 and 15 as children.

Example 3 — Multiple Searches

$ Input: operations = [["insert",20],["insert",10],["insert",30],["search",10],["search",30]]

› Output: [10,20,30]

💡 Note: Build tree with 20, 10, 30. Search 10 brings it to root. Search 30 brings it to root. Final configuration shows frequent access pattern.

Constraints

1 ≤ operations.length ≤ 100
operations[i] is either ["insert", value] or ["search", value]
-1000 ≤ value ≤ 1000
All insert values are unique

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is using three distinct rotation patterns (zig, zig-zig, zig-zag) based on node-parent-grandparent relationships to efficiently move frequently accessed nodes closer to the root. The optimal approach implements proper splay operations that maintain better tree balance than naive single rotations. Time: O(n log n) amortized, Space: O(n)

Common Approaches

✓ Naive Splay with Linear Search

⏱️ Time: O(n²) Space: O(n)

For each operation, traverse the tree linearly to find the target node, then perform repeated single rotations (zig operations) to move it to the root. This doesn't take advantage of the optimal zig-zig and zig-zag patterns.

Proper Splay Tree with Zig-Zig and Zig-Zag

⏱️ Time: O(n log n) Space: O(n)

Uses the correct splay tree algorithm with zig (single rotation), zig-zig (double rotation same side), and zig-zag (double rotation opposite sides) operations based on the node's position relative to parent and grandparent.

Naive Splay with Linear Search — Algorithm Steps

Traverse tree to find target node
Perform single rotations repeatedly until node reaches root
Repeat for each operation

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Target

Search tree linearly to locate the target node

Single Rotations

Perform repeated zig operations until node reaches root

Result

Node is at root but tree may be unbalanced

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
    struct TreeNode* parent;
} TreeNode;

typedef struct {
    TreeNode* root;
} SplayTree;

TreeNode* createNode(int val) {
    TreeNode* node = malloc(sizeof(TreeNode));
    node->val = val;
    node->left = node->right = node->parent = NULL;
    return node;
}

void rightRotate(SplayTree* tree, TreeNode* node) {
    TreeNode* leftChild = node->left;
    node->left = leftChild->right;
    if (leftChild->right) leftChild->right->parent = node;
    leftChild->parent = node->parent;
    if (!node->parent) {
        tree->root = leftChild;
    } else if (node->parent->left == node) {
        node->parent->left = leftChild;
    } else {
        node->parent->right = leftChild;
    }
    leftChild->right = node;
    node->parent = leftChild;
}

void leftRotate(SplayTree* tree, TreeNode* node) {
    TreeNode* rightChild = node->right;
    node->right = rightChild->left;
    if (rightChild->left) rightChild->left->parent = node;
    rightChild->parent = node->parent;
    if (!node->parent) {
        tree->root = rightChild;
    } else if (node->parent->left == node) {
        node->parent->left = rightChild;
    } else {
        node->parent->right = rightChild;
    }
    rightChild->left = node;
    node->parent = rightChild;
}

void splay(SplayTree* tree, TreeNode* node) {
    while (node->parent) {
        if (node->parent->left == node) {
            rightRotate(tree, node->parent);
        } else {
            leftRotate(tree, node->parent);
        }
    }
}

int search(SplayTree* tree, int val) {
    TreeNode* node = tree->root;
    while (node) {
        if (val == node->val) {
            splay(tree, node);
            return 1;
        } else if (val < node->val) {
            node = node->left;
        } else {
            node = node->right;
        }
    }
    return 0;
}

void insert(SplayTree* tree, int val) {
    if (!tree->root) {
        tree->root = createNode(val);
        return;
    }
    
    TreeNode* node = tree->root;
    TreeNode* parent = NULL;
    while (node) {
        parent = node;
        if (val < node->val) node = node->left;
        else node = node->right;
    }
    
    TreeNode* newNode = createNode(val);
    newNode->parent = parent;
    if (val < parent->val) parent->left = newNode;
    else parent->right = newNode;
    
    splay(tree, newNode);
}

void inorderHelper(TreeNode* node, int* result, int* size) {
    if (node) {
        inorderHelper(node->left, result, size);
        result[(*size)++] = node->val;
        inorderHelper(node->right, result, size);
    }
}

int* solution(char operations[][20], int opCount, int* returnSize) {
    SplayTree tree = {NULL};
    for (int i = 0; i < opCount; i++) {
        char* cmd = strtok(operations[i], ",");
        int val = atoi(strtok(NULL, ","));
        if (strcmp(cmd, "insert") == 0) {
            insert(&tree, val);
        } else if (strcmp(cmd, "search") == 0) {
            search(&tree, val);
        }
    }
    
    int* result = malloc(1000 * sizeof(int));
    *returnSize = 0;
    inorderHelper(tree.root, result, returnSize);
    return result;
}

int main() {
    // Simplified input parsing
    char operations[100][20];
    int opCount = 0;
    
    // Read and parse operations (simplified)
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing - assumes format like insert,5;search,3
    char* token = strtok(line, ";");
    while (token && opCount < 100) {
        strcpy(operations[opCount], token);
        opCount++;
        token = strtok(NULL, ";");
    }
    
    int returnSize;
    int* result = solution(operations, opCount, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each operation may require O(n) search plus O(n) single rotations in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Space for tree nodes and recursion stack depth up to n

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~45 min Avg. Time

324 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Splay Tree - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Naive Splay with Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler