Deep Merge of Two Objects - Practice Coding Problems

Deep Merge of Two Objects - Problem

JavaScript Medium

You're tasked with implementing a deep merge function that intelligently combines two JavaScript objects or arrays. This is a common operation in configuration management, data processing, and API response handling.

Given two values obj1 and obj2, return a deeply merged result following these rules:

Objects: The result contains all keys from both objects. If a key exists in both, recursively deep merge their values.
Arrays: The result has the length of the longer array. Treat indices as keys and apply the same merging logic.
Primitives: When merging incompatible types or primitives, obj2 takes precedence.

For example, merging {a: 1, b: {x: 2}} and {b: {y: 3}, c: 4} should produce {a: 1, b: {x: 2, y: 3}, c: 4}.

Note: You can assume both inputs are valid JSON-parsed values.

Input & Output

example_1.js — Basic Object Merge

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

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

💡 Note: Object merging: 'a' comes from obj1, 'c' comes from obj2, and 'b' is deeply merged containing both 'x' and 'y'

example_2.js — Array Merge

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

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

💡 Note: Array merging: Result has length 3 (longer array). Index 0: merge 1 and {"b": 3} → {"b": 3} (obj2 wins). Index 1: merge {"a": 2} and 4 → 4 (obj2 wins). Index 2: only obj2 has value → 5

example_3.js — Mixed Types

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

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

💡 Note: When merging arrays of different lengths, the result takes the longer length. Each index is merged: merge(1,3)→3, merge(2,4)→4, merge(undefined,5)→5

Constraints

Both inputs are valid JSON-parsed values
Objects can be nested up to 1000 levels deep
Arrays can contain up to 10⁴ elements
obj2 takes precedence when merging incompatible types

Visualization

Tap to expand

Understanding the Visualization

Compare Collections

Check if both collections are the same type (both recipe books or both ingredient lists)

Start with Base

Use the first collection as your starting point

Add New Recipes

For each recipe in the second collection, either add it (if new) or merge it (if duplicate)

Recursive Merging

When merging duplicate recipes, recursively merge their contents

Final Collection

Result contains all recipes with intelligently combined contents

Key Takeaway

🎯 Key Insight: Deep merging is naturally recursive - containers need their contents merged intelligently, while individual values can be directly replaced. The elegance comes from letting the recursion handle the complexity of nested structures automatically.

Asked in

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

The optimal solution uses recursion to elegantly handle nested structures. Key insights: check type compatibility first, use recursion for containers (objects/arrays), and let obj2 take precedence for primitives and type conflicts. Time complexity is O(n) where n is the total number of properties.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Deep Merge (Optimal)	O(n)	O(d)	Use recursion to elegantly handle nested structures in a single pass
Iterative Deep Clone and Merge	O(n²)	O(n)	Manually iterate through all keys and handle each case separately

Recursive Deep Merge (Optimal) — Algorithm Steps

Check if obj1 and obj2 are compatible types
If incompatible or obj1 is primitive, return obj2
If both are objects, merge all keys recursively
If both are arrays, merge indices up to the longer length
For each nested structure, recursively call deepMerge

Visualization

Tap to expand

Step-by-Step Walkthrough

Type Check

Determine if objects are compatible for merging

Base Case

Handle primitives and incompatible types

Recursive Case

For containers, recursively merge contents

Combine Results

Build final merged object

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <json-c/json.h>

struct json_object* deepMerge(struct json_object* obj1, struct json_object* obj2) {
    // If obj1 is not a container, obj2 takes precedence
    if (!obj1 || (!json_object_is_type(obj1, json_type_object) && 
                  !json_object_is_type(obj1, json_type_array))) {
        return json_object_get(obj2);
    }
    
    enum json_type type1 = json_object_get_type(obj1);
    enum json_type type2 = json_object_get_type(obj2);
    
    // If types don't match, obj2 takes precedence
    if (type1 != type2) {
        return json_object_get(obj2);
    }
    
    // Both are objects
    if (type1 == json_type_object) {
        struct json_object* result = json_object_new_object();
        
        // Copy all properties from obj1
        json_object_object_foreach(obj1, key, val) {
            json_object_object_add(result, key, json_object_get(val));
        }
        
        // Merge properties from obj2
        json_object_object_foreach(obj2, key, val) {
            struct json_object* existing;
            if (json_object_object_get_ex(result, key, &existing)) {
                // Key exists - merge recursively
                struct json_object* merged = deepMerge(existing, val);
                json_object_object_del(result, key);
                json_object_object_add(result, key, merged);
            } else {
                // New key from obj2
                json_object_object_add(result, key, json_object_get(val));
            }
        }
        
        return result;
    }
    
    // Both are arrays
    if (type1 == json_type_array) {
        int len1 = json_object_array_length(obj1);
        int len2 = json_object_array_length(obj2);
        int maxLen = len1 > len2 ? len1 : len2;
        
        struct json_object* result = json_object_new_array();
        
        for (int i = 0; i < maxLen; i++) {
            struct json_object* val1 = i < len1 ? json_object_array_get_idx(obj1, i) : NULL;
            struct json_object* val2 = i < len2 ? json_object_array_get_idx(obj2, i) : NULL;
            
            if (val1 && val2) {
                json_object_array_add(result, deepMerge(val1, val2));
            } else if (val2) {
                json_object_array_add(result, json_object_get(val2));
            } else if (val1) {
                json_object_array_add(result, json_object_get(val1));
            }
        }
        
        return result;
    }
    
    return json_object_get(obj2);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each key/index is visited exactly once, where n is total number of properties

✓ Linear Growth

Space Complexity

O(d)

Recursion depth d plus space for the result object

✓ Linear Space

43.7K Views

High Frequency

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

Recursive Deep Merge (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler