Deep Merge of Two Objects - Practice Coding Problems

Deep Merge of Two Objects - Problem

JavaScript Medium

Given two JavaScript values obj1 and obj2, return a deep merged value according to these rules:

Objects: If both values are objects, the resulting object should have all keys that exist on either object. If a key belongs to both objects, recursively deep merge the two associated values. Otherwise, add the key-value pair to the resulting object.

Arrays: If both values are arrays, the resulting array should be the same length as the longer array. Apply the same merging logic as objects, but treat the array indices as keys.

Otherwise: The resulting value is obj2 (obj2 takes precedence).

You can assume obj1 and obj2 are the output of JSON.parse().

Input & Output

Example 1 — Object Merging

$ Input: obj1 = {"a": 1, "b": {"x": 2}}, obj2 = {"b": {"y": 3}, "c": 4}

› Output: {"a": 1, "b": {"x": 2, "y": 3}, "c": 4}

💡 Note: Key 'a' only in obj1, key 'c' only in obj2, key 'b' exists in both so we recursively merge the nested objects

Example 2 — Array Merging

$ Input: obj1 = [1, 2], obj2 = [3, 4, 5]

› Output: [3, 4, 5]

💡 Note: Both arrays merge by index: index 0 gets obj2[0]=3, index 1 gets obj2[1]=4, index 2 only exists in obj2 so gets 5

Example 3 — Mixed Types

$ Input: obj1 = {"a": [1, 2]}, obj2 = {"a": [3, 4, 5], "b": "hello"}

› Output: {"a": [3, 4, 5], "b": "hello"}

💡 Note: Objects merge, then arrays at key 'a' merge by index giving [3, 4, 5], key 'b' only in obj2

Constraints

obj1 and obj2 are valid JSON values
Maximum depth ≤ 1000
Objects can have up to 1000 keys
Arrays can have up to 1000 elements

Visualization

Tap to expand

Understanding the Visualization

Input

Two JSON values that may be objects, arrays, or primitives

Type Check

Determine merge strategy based on value types

Output

Single merged structure following deep merge rules

Key Takeaway

🎯 Key Insight: Recursion naturally handles nested structures by applying the same merge logic at every level

Asked in

M Microsoft 35 G Google 28 F Facebook 22

The key insight is to recursively check types and merge accordingly: objects merge all keys with recursive merging for conflicts, arrays merge by index up to max length, otherwise obj2 takes precedence. Best approach uses recursive traversal. Time: O(n + m), Space: O(d)

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Deep Merge	O(n + m)	O(d)	Recursively merge objects and arrays by checking types and handling each case

Recursive Deep Merge — Algorithm Steps

Step 1: Check if both values are objects - if yes, merge all keys recursively
Step 2: Check if both values are arrays - if yes, merge by index up to max length
Step 3: Otherwise, return obj2 (obj2 takes precedence)

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Types

Determine if both values are objects, arrays, or different types

Merge Recursively

For objects: merge all keys. For arrays: merge by index

Return Result

Return merged structure or obj2 if types differ

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

cJSON* solution(cJSON* obj1, cJSON* obj2) {
    // If both are objects
    if (cJSON_IsObject(obj1) && cJSON_IsObject(obj2)) {
        cJSON* result = cJSON_CreateObject();
        cJSON* item1 = NULL;
        cJSON* item2 = NULL;
        
        // Add all items from obj1
        cJSON_ArrayForEach(item1, obj1) {
            cJSON* corresponding = cJSON_GetObjectItemCaseSensitive(obj2, item1->string);
            if (corresponding != NULL) {
                cJSON_AddItemToObject(result, item1->string, solution(item1, corresponding));
            } else {
                cJSON_AddItemToObject(result, item1->string, cJSON_Duplicate(item1, 1));
            }
        }
        
        // Add remaining items from obj2
        cJSON_ArrayForEach(item2, obj2) {
            if (!cJSON_GetObjectItemCaseSensitive(result, item2->string)) {
                cJSON_AddItemToObject(result, item2->string, cJSON_Duplicate(item2, 1));
            }
        }
        
        return result;
    }
    
    // If both are arrays
    else if (cJSON_IsArray(obj1) && cJSON_IsArray(obj2)) {
        int size1 = cJSON_GetArraySize(obj1);
        int size2 = cJSON_GetArraySize(obj2);
        int maxSize = size1 > size2 ? size1 : size2;
        
        cJSON* result = cJSON_CreateArray();
        
        for (int i = 0; i < maxSize; i++) {
            cJSON* val1 = i < size1 ? cJSON_GetArrayItem(obj1, i) : NULL;
            cJSON* val2 = i < size2 ? cJSON_GetArrayItem(obj2, i) : NULL;
            
            if (val1 && val2) {
                cJSON_AddItemToArray(result, solution(val1, val2));
            } else if (val1) {
                cJSON_AddItemToArray(result, cJSON_Duplicate(val1, 1));
            } else if (val2) {
                cJSON_AddItemToArray(result, cJSON_Duplicate(val2, 1));
            }
        }
        
        return result;
    }
    
    // Otherwise, obj2 takes precedence
    else {
        return cJSON_Duplicate(obj2, 1);
    }
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    cJSON* obj1 = cJSON_Parse(line1);
    cJSON* obj2 = cJSON_Parse(line2);
    
    cJSON* result = solution(obj1, obj2);
    char* output = cJSON_PrintUnformatted(result);
    
    printf("%s\n", output);
    
    cJSON_Delete(obj1);
    cJSON_Delete(obj2);
    cJSON_Delete(result);
    free(output);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Must visit every key/index in both objects, where n and m are total elements

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth d plus space for the merged result structure

✓ Linear Space

28.5K Views

Medium Frequency

~25 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Recursive Deep Merge — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler