Undefined to Null - Practice Coding Problems

Undefined to Null - Problem

JavaScript Medium

When working with JavaScript data structures, you'll often encounter undefined values that can cause issues during JSON serialization. Your task is to create a function that transforms any deeply nested object or array by replacing all undefined values with null.

Why does this matter? When you call JSON.stringify() on an object containing undefined values, those properties are completely omitted from the resulting JSON string. However, null values are preserved. This function ensures your serialized data maintains its structure and doesn't lose important properties.

Example: JSON.stringify({a: undefined, b: 5}) returns "{"b":5}", but JSON.stringify({a: null, b: 5}) returns "{"a":null,"b":5}".

The input can be arbitrarily nested with objects, arrays, primitive values, and undefined values at any level.

Input & Output

example_1.js — Basic Object

$ Input: {"a": undefined, "b": 5, "c": undefined}

› Output: {"a": null, "b": 5, "c": null}

💡 Note: All undefined values at the root level are replaced with null, while other values remain unchanged

example_2.js — Nested Array

$ Input: [1, undefined, [undefined, "hello", undefined], {"x": undefined, "y": 42}]

› Output: [1, null, [null, "hello", null], {"x": null, "y": 42}]

💡 Note: Nested undefined values in arrays and objects are recursively replaced with null at all levels

example_3.js — Edge Cases

$ Input: {"nested": {"deep": {"value": undefined}}, "array": [undefined, null, 0, false]}

› Output: {"nested": {"deep": {"value": null}}, "array": [null, null, 0, false]}

💡 Note: Deeply nested undefined values are found and replaced. Note that existing null, 0, and false values remain unchanged

Constraints

The input obj can be any valid JavaScript value
Maximum nesting depth is 1000 levels
Objects can have up to 10⁴ properties
Arrays can have up to 10⁴ elements
Only undefined values should be replaced, not other falsy values

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin at the top level of the data structure

Examine Each Value

Check if the current value is undefined

Replace if Undefined

If undefined found, immediately replace with null

Recurse into Nested

For objects/arrays, recursively process all nested values

Complete in One Pass

Each value is processed exactly once

Key Takeaway

🎯 Key Insight: By processing each value exactly once during traversal, we achieve optimal O(n) time complexity while maintaining clean, readable recursive code.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses single-pass recursive traversal to visit each value exactly once. When we encounter an undefined value, we immediately replace it with null. For objects and arrays, we recursively process all nested values. This achieves O(n) time complexity where n is the total number of values, making it much more efficient than multiple-pass approaches.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Passes)	O(n²)	O(n)	Repeatedly scan the entire structure until no undefined values remain
Single Pass Recursive (Optimal)	O(n)	O(d)	Traverse the structure once, replacing undefined values during the single traversal

Brute Force (Multiple Passes) — Algorithm Steps

Convert the input to a string and check for 'undefined'
If found, traverse the entire structure replacing undefined with null
Repeat until no more undefined values exist
Return the cleaned structure

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass

Scan entire structure looking for undefined values

Replace Found

Replace undefined with null, mark that changes were made

Second Pass

Scan again to check for any missed undefined values

Complete

No more undefined values found, algorithm terminates

Code -

solution.c — C

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

typedef struct Value {
    enum { INT, STRING, NULL_VAL, ARRAY, OBJECT } type;
    union {
        int int_val;
        char* str_val;
        struct {
            struct Value** items;
            int size;
        } array;
        struct {
            char** keys;
            struct Value** values;
            int size;
        } object;
    } data;
} Value;

int checkAndReplace(Value* obj) {
    int found = 0;
    
    if (obj->type == ARRAY) {
        for (int i = 0; i < obj->data.array.size; i++) {
            if (obj->data.array.items[i]->type == NULL_VAL) {
                found = 1;
            } else {
                found |= checkAndReplace(obj->data.array.items[i]);
            }
        }
    } else if (obj->type == OBJECT) {
        for (int i = 0; i < obj->data.object.size; i++) {
            if (obj->data.object.values[i]->type == NULL_VAL) {
                found = 1;
            } else {
                found |= checkAndReplace(obj->data.object.values[i]);
            }
        }
    }
    
    return found;
}

Value* undefinedToNull(Value* obj) {
    int hasUndefined = 1;
    
    while (hasUndefined) {
        hasUndefined = checkAndReplace(obj);
    }
    
    return obj;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might traverse the structure multiple times, where n is the total number of values

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed for string conversion and recursive call stack

⚡ Linearithmic Space

34.2K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler