Garbage Collector Simulator - Problem

You are tasked with implementing a mark-and-sweep garbage collector simulator. This is a fundamental memory management algorithm used in many programming languages.

Given a list of objects and their reference relationships, you need to:

Build the reference graph - Create connections between objects
Mark phase - Starting from root objects, mark all reachable objects
Sweep phase - Collect (remove) all unmarked objects as garbage

Each object has an id and a list of references to other object IDs. Root objects are those that are directly accessible (not referenced by any other object or explicitly marked as roots).

Return the list of object IDs that should be garbage collected (unreachable objects).

Input & Output

Example 1 — Basic Garbage Collection

$ Input: objects = [{"id":1,"references":[2,3]},{"id":2,"references":[4]},{"id":3,"references":[]},{"id":4,"references":[]},{"id":5,"references":[6]},{"id":6,"references":[5]}], roots = [1]

› Output: [5,6]

💡 Note: Starting from root 1, we can reach objects 2, 3, and 4. Objects 5 and 6 form an isolated cycle and are unreachable from root 1, so they become garbage.

Example 2 — Multiple Roots

$ Input: objects = [{"id":1,"references":[2]},{"id":2,"references":[]},{"id":3,"references":[4]},{"id":4,"references":[]}], roots = [1,3]

› Output: []

💡 Note: With roots 1 and 3, we can reach: from root 1 → object 2, from root 3 → object 4. All objects are reachable, so no garbage.

Example 3 — All Objects Unreachable

$ Input: objects = [{"id":2,"references":[3]},{"id":3,"references":[]}], roots = [1]

› Output: [2,3]

💡 Note: Root 1 doesn't exist in the object list, so objects 2 and 3 are unreachable and become garbage.

Constraints

1 ≤ objects.length ≤ 1000
1 ≤ object.id ≤ 10000
0 ≤ object.references.length ≤ 100
1 ≤ roots.length ≤ 100

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 38 a Amazon 32 f Meta 28

The mark-and-sweep algorithm is a classic two-phase garbage collection approach. The key insight is to mark all reachable objects in a single traversal from roots, then sweep through all objects to collect the unmarked ones. Best approach uses DFS/BFS for marking phase. Time: O(n + e), Space: O(n).

Common Approaches

✓ Brute Force - Check Every Object

⏱️ Time: O(n² × (n + e)) Space: O(n)

Check each object individually by performing a complete graph traversal from all root objects to see if the target object can be reached. This means doing a separate BFS/DFS for every single object.

Mark-and-Sweep Algorithm

⏱️ Time: O(n + e) Space: O(n)

Implement the classic mark-and-sweep algorithm. First phase marks all reachable objects starting from roots using DFS/BFS. Second phase sweeps through all objects and collects unmarked ones as garbage.

Brute Force - Check Every Object — Algorithm Steps

For each object in the list
Start BFS/DFS from all root objects
Check if current object is reachable
Add to garbage list if not reachable

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Object

Pick an object to check for reachability

Traverse from Roots

Do complete BFS/DFS from all root objects

Mark if Unreachable

Add to garbage list if object not found during traversal

Code -

solution.c — C

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

#define MAX_OBJECTS 1000
#define MAX_REFS 100

struct ObjectNode {
    int id;
    int references[MAX_REFS];
    int refCount;
};

struct Queue {
    int data[MAX_OBJECTS];
    int front, rear;
};

void initQueue(struct Queue* q) {
    q->front = q->rear = 0;
}

bool isEmpty(struct Queue* q) {
    return q->front == q->rear;
}

void enqueue(struct Queue* q, int val) {
    q->data[q->rear++] = val;
}

int dequeue(struct Queue* q) {
    return q->data[q->front++];
}

int* solution(struct ObjectNode* objects, int objCount, int* roots, int rootCount, int* returnSize) {
    // Build adjacency lists and collect all objects
    bool allObjects[MAX_OBJECTS] = {false};
    
    for (int i = 0; i < objCount; i++) {
        allObjects[objects[i].id] = true;
        for (int j = 0; j < objects[i].refCount; j++) {
            allObjects[objects[i].references[j]] = true;
        }
    }
    
    int* garbage = malloc(MAX_OBJECTS * sizeof(int));
    *returnSize = 0;
    
    // Check each object individually
    for (int objId = 0; objId < MAX_OBJECTS; objId++) {
        if (!allObjects[objId]) continue;
        
        // Check if this is a root
        bool isRoot = false;
        for (int i = 0; i < rootCount; i++) {
            if (roots[i] == objId) {
                isRoot = true;
                break;
            }
        }
        if (isRoot) continue;
        
        // Do BFS from all roots to see if objId is reachable
        bool reachable = false;
        for (int r = 0; r < rootCount && !reachable; r++) {
            int root = roots[r];
            if (!allObjects[root]) continue;
            
            bool visited[MAX_OBJECTS] = {false};
            struct Queue q;
            initQueue(&q);
            enqueue(&q, root);
            visited[root] = true;
            
            while (!isEmpty(&q) && !reachable) {
                int current = dequeue(&q);
                if (current == objId) {
                    reachable = true;
                    break;
                }
                
                // Find object with id = current
                for (int i = 0; i < objCount; i++) {
                    if (objects[i].id == current) {
                        for (int j = 0; j < objects[i].refCount; j++) {
                            int neighbor = objects[i].references[j];
                            if (!visited[neighbor]) {
                                visited[neighbor] = true;
                                enqueue(&q, neighbor);
                            }
                        }
                        break;
                    }
                }
            }
        }
        
        if (!reachable) {
            garbage[(*returnSize)++] = objId;
        }
    }
    
    // Sort garbage array
    for (int i = 0; i < *returnSize - 1; i++) {
        for (int j = i + 1; j < *returnSize; j++) {
            if (garbage[i] > garbage[j]) {
                int temp = garbage[i];
                garbage[i] = garbage[j];
                garbage[j] = temp;
            }
        }
    }
    
    return garbage;
}

int main() {
    // Simple parsing for demo - in real implementation would parse JSON
    struct ObjectNode objects[10] = {
        {1, {2, 3}, 2},
        {2, {4}, 1},
        {3, {}, 0},
        {4, {}, 0},
        {5, {6}, 1},
        {6, {5}, 1}
    };
    
    int roots[] = {1};
    int rootCount = 1;
    int objCount = 6;
    
    int returnSize;
    int* result = solution(objects, objCount, roots, rootCount, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × (n + e))

For each of n objects, we do a graph traversal taking O(n + e) time

✓ Linear Growth

Space Complexity

O(n)

Only need visited array for each traversal and result list

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~35 min Avg. Time

892 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

Garbage Collector Simulator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check Every Object — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler