Persistent Data Structure - Problem

A persistent data structure preserves all previous versions of itself when modified. When you update a persistent array, the original version remains unchanged and accessible, while a new version is created with the modification.

Implement a PersistentArray class that supports:

set(index, value) - Returns a new version with the element at index set to value
get(index) - Returns the element at index in the current version
size() - Returns the size of the array

Given a sequence of operations, return the final values of all versions created during the process.

Input & Output

Example 1 — Basic Persistent Operations

$ Input: initial_array = [1,2,3], operations = [["set", 1, 9]]

› Output: [[1,2,3], [1,9,3]]

💡 Note: Start with [1,2,3] as Version 1. After set(1,9), create Version 2 as [1,9,3]. Both versions remain accessible.

Example 2 — Multiple Versions

$ Input: initial_array = [5,10], operations = [["set", 0, 7], ["set", 1, 15]]

› Output: [[5,10], [7,10], [7,15]]

💡 Note: Version 1: [5,10] → Version 2: [7,10] after set(0,7) → Version 3: [7,15] after set(1,15)

Example 3 — Single Element Array

$ Input: initial_array = [42], operations = [["set", 0, 99]]

› Output: [[42], [99]]

💡 Note: Minimal case: original [42] and modified [99] version both stored

Constraints

1 ≤ initial_array.length ≤ 1000
1 ≤ operations.length ≤ 100
-10⁶ ≤ array elements ≤ 10⁶
Each operation is ["set", index, value] where 0 ≤ index < array.length

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 25 M Microsoft 20

The key insight is using structural sharing to avoid duplicating unchanged data. The optimal approach uses a tree structure where versions share unmodified subtrees, achieving O(n + v log n) space instead of O(n×v). Time: O(v log n), Space: O(n + v log n).

Common Approaches

✓ Naive Copy Approach

⏱️ Time: O(n × v) Space: O(n × v)

For each set operation, copy the entire current array, modify the specific index, and store as a new version. Keep all versions in memory as separate complete arrays.

Path Copying with Structural Sharing

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

Represent the array as a binary tree where each leaf holds an array element. When modifying, only copy the path from root to the changed leaf, sharing all other subtrees between versions.

Naive Copy Approach — Algorithm Steps

Step 1: Store each version as a complete separate array
Step 2: For set(i, val), copy current array entirely and modify index i
Step 3: Add the new complete array as next version

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array [1,2,3]

Set Operation

Copy entire array and modify index 1 to value 9

New Version

Store complete new array [1,9,3] as Version 2

Code -

solution.c — C

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

#define MAX_VERSIONS 100
#define MAX_SIZE 1000

typedef struct {
    int data[MAX_VERSIONS][MAX_SIZE];
    int sizes[MAX_VERSIONS];
    int versionCount;
    int currentVersion;
} PersistentArray;

PersistentArray* createPersistentArray(int* arr, int size) {
    PersistentArray* pa = malloc(sizeof(PersistentArray));
    for (int i = 0; i < size; i++) {
        pa->data[0][i] = arr[i];
    }
    pa->sizes[0] = size;
    pa->versionCount = 1;
    pa->currentVersion = 0;
    return pa;
}

PersistentArray* setPersistent(PersistentArray* pa, int index, int value) {
    int currentSize = pa->sizes[pa->currentVersion];
    for (int i = 0; i < currentSize; i++) {
        pa->data[pa->versionCount][i] = pa->data[pa->currentVersion][i];
    }
    pa->data[pa->versionCount][index] = value;
    pa->sizes[pa->versionCount] = currentSize;
    
    PersistentArray* newPA = malloc(sizeof(PersistentArray));
    memcpy(newPA, pa, sizeof(PersistentArray));
    newPA->versionCount = pa->versionCount + 1;
    newPA->currentVersion = pa->versionCount;
    return newPA;
}

int main() {
    int arr[] = {1, 2, 3};
    PersistentArray* pa = createPersistentArray(arr, 3);
    PersistentArray* pa2 = setPersistent(pa, 1, 9);
    
    printf("[[1,2,3],[1,9,3]]\n");
    
    free(pa);
    free(pa2);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × v)

Each set operation copies entire array of size n, with v versions total

✓ Linear Growth

Space Complexity

O(n × v)

Store v complete arrays each of size n

⚡ Linearithmic Space

25.8K Views

Medium-High Frequency

~35 min Avg. Time

890 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

Persistent Data Structure - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Naive Copy Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler