JSON Deep Equal - Practice Coding Problems

JSON Deep Equal - Problem

JavaScript Medium

Given two values o1 and o2, return a boolean value indicating whether the two values are deeply equal.

For two values to be deeply equal, the following conditions must be met:

If both values are primitive types (string, number, boolean, null), they are deeply equal if they pass the === equality check
If both values are arrays, they are deeply equal if they have the same elements in the same order, and each element is also deeply equal according to these conditions
If both values are objects, they are deeply equal if they have the same keys, and the associated values for each key are also deeply equal according to these conditions

Note: You may assume both values are the output of JSON.parse. In other words, they are valid JSON.

Constraint: Please solve it without using lodash's _.isEqual() function.

Input & Output

Example 1 — Basic Object Comparison

$ Input: o1 = {"name": "John", "age": 25}, o2 = {"name": "John", "age": 25}

› Output: true

💡 Note: Both objects have same keys ("name", "age") with identical values ("John", 25), so they are deeply equal

Example 2 — Array with Different Elements

$ Input: o1 = [1, 2, 3], o2 = [1, 2, 4]

› Output: false

💡 Note: Arrays have same length but different elements at index 2: 3 ≠ 4, so not deeply equal

Example 3 — Nested Structure Match

$ Input: o1 = {"user": {"id": 1, "pets": ["cat"]}}, o2 = {"user": {"id": 1, "pets": ["cat"]}}

› Output: true

💡 Note: Both have same nested structure: user.id = 1 and user.pets = ["cat"] in both objects

Constraints

Both values are valid JSON (output of JSON.parse)
Objects can have nested properties of any depth
Arrays can contain mixed types (numbers, strings, objects, arrays)
Cannot use lodash's _.isEqual() function

Visualization

Tap to expand

Understanding the Visualization

Input

Two JSON objects with nested structures

Process

Recursively compare types, keys, values, and array elements

Output

Boolean indicating if structures are deeply equal

Key Takeaway

🎯 Key Insight: Recursion naturally handles nested structures by breaking down complex comparisons into simpler type-specific checks

Asked in

G Google 35 F Facebook 28 A Amazon 22 M Microsoft 18

The key insight is to use recursion to handle nested structures naturally. Compare types first, then recursively check all properties/elements. The optimized approach adds early termination and size checks for better performance. Time: O(n), Space: O(d) where n is total nodes and d is nesting depth.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Recursive with Early Termination	O(n)	O(d)	Add type checking optimizations and early termination for better performance
Brute Force Recursive Comparison	O(n)	O(d)	Recursively check all properties and array elements without optimization

Optimized Recursive with Early Termination — Algorithm Steps

Step 1: Early return for reference equality
Step 2: Optimized type checking
Step 3: Early termination on first difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Quick Checks

Reference equality, null checks, type checks

Size Comparison

Compare lengths/sizes before deep comparison

Early Exit

Stop immediately on first difference found

Code -

solution.c — C

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

bool solution(const char* o1, const char* o2) {
    // Early length check
    if (strlen(o1) != strlen(o2)) {
        return false;
    }
    
    // Early termination on first character mismatch
    return strcmp(o1, o2) == 0;
}

int main() {
    char o1[10000], o2[10000];
    fgets(o1, sizeof(o1), stdin);
    fgets(o2, sizeof(o2), stdin);
    
    o1[strcspn(o1, "\n")] = 0;
    o2[strcspn(o2, "\n")] = 0;
    
    bool result = solution(o1, o2);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case must visit all nodes, but early termination improves average case performance

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth d equals maximum nesting level, same as brute force

✓ Linear Space

28.5K Views

Medium Frequency

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

Optimized Recursive with Early Termination — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler