Is JSON Deep Equal easy or hard?

JSON Deep Equal is generally considered a medium-level problem. The core idea is straightforward, but careful handling of arrays, objects, key comparisons, and recursion makes it slightly tricky. Edge cases like null values and mismatched types are where many implementations fail.

JSON Deep Equal Python/Java solution

The same recursive logic works across languages. In Python, dictionaries and lists are compared recursively. In Java, maps and lists can be traversed with recursion or a stack while checking key sets and element positions. The complexity remains O(n) time and O(n) space.

How to solve JSON Deep Equal in O(n)?

Traverse both JSON values using depth-first search. Compare primitives directly, check array lengths and recursively compare each index, and verify objects have identical key sets before comparing their values. Since each node in the JSON structure is processed once, the algorithm achieves O(n) time complexity.

What is the best approach for JSON Deep Equal?

Recursive deep comparison is the most reliable approach. It walks both JSON structures simultaneously, comparing primitives directly and recursively checking arrays and objects. This guarantees correctness regardless of key ordering or nesting depth. The approach runs in O(n) time where n is the number of elements and properties in the JSON structure.

Is JSON Deep Equal asked at Google/Amazon/Meta?

Deep equality checks appear in frontend and JavaScript-focused interviews, particularly for companies that test practical language knowledge. Variants of this problem are common in frontend roles at companies like Meta, Amazon, and startups where understanding JavaScript objects and recursion is essential.

What data structure is used in JSON Deep Equal?

The algorithm treats JSON as a tree-like structure composed of primitives, arrays, and objects. Recursion or an explicit stack is used to perform depth-first traversal. Objects behave like hash maps where keys must match before comparing values recursively.

What is the time complexity of JSON Deep Equal?

The optimal solution runs in O(n) time because each value, array element, or object property is visited exactly once during traversal. Space complexity is O(n) in the worst case due to recursion depth or an explicit stack when handling deeply nested structures.

Description Hints 3 Solution Video 13:53

2628. JSON Deep Equal

Medium38.8% acceptancePremium elsewhere, free here

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

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

If both values are primitive types, 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.

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

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

Example 1:

Input: o1 = {"x":1,"y":2}, o2 = {"x":1,"y":2}
Output: true
Explanation: The keys and values match exactly.

Example 2:

Input: o1 = {"y":2,"x":1}, o2 = {"x":1,"y":2}
Output: true
Explanation: Although the keys are in a different order, they still match exactly.

Example 3:

Input: o1 = {"x":null,"L":[1,2,3]}, o2 = {"x":null,"L":["1","2","3"]}
Output: false
Explanation: The array of numbers is different from the array of strings.

Example 4:

Input: o1 = true, o2 = false
Output: false
Explanation: true !== false

Constraints:

1 <= JSON.stringify(o1).length <= 10⁵
1 <= JSON.stringify(o2).length <= 10⁵
maxNestingDepth <= 1000

Hints open one at a time

Hint 1

You can check if a value is an array with the Array.isArray() method. You can check if a value is an object by saying typeof obj === 'object' && obj !== null. You can list the keys of an object with the Object.keys() function.

Hint 2

If two objects have different keys or two arrays have a different length, they cannot be equal.

Hint 3

You can use recursion to investigate if the values of an object or array are also deeply equal. The base case is when the values are primitives (string, number, etc), at which case the check is a trivial === check.

13:53

Still stuck?Read the written solution, or watch a walkthrough.

Open solution

2628. JSON Deep Equal

Hints open one at a time

Similar problems