Introduction

Comparing arrays while ignoring order sounds easy until you decide what “same elements” really means. Do duplicates matter? Are the elements simple primitives or nested objects? Are you comparing as sets, as multisets, or as canonicalized structures?

The correct algorithm follows directly from those semantics. Most bugs happen when code uses set equality even though multiplicity actually matters.

Decide the Equality Rule First

These three meanings are different:

1. same unique values, ignoring duplicates
2. same values with the same counts
3. same objects after normalization

For example:

• '[1, 2, 3] and [3, 2, 1] are equal under all three simple primitive interpretations'
• '[1, 1, 2] and [1, 2, 2] are equal as sets but not equal as multisets'

If you skip this decision, you can write code that passes tests while still encoding the wrong business rule.

Count-Aware Comparison for Primitive Arrays

If duplicates matter, compare frequency counts.

1from collections import Counter
2
3
4def same_multiset(a, b):
5    return Counter(a) == Counter(b)
6
7
8print(same_multiset([1, 2, 2, 3], [3, 2, 1, 2]))
9print(same_multiset([1, 2, 2, 3], [1, 2, 3, 3]))

This is often the best answer in Python because it directly expresses multiset equality.

In JavaScript, a map-based frequency count does the same thing.

1function sameMultiset(a, b) {
2  if (a.length !== b.length) return false;
3
4  const freq = new Map();
5  for (const value of a) {
6    freq.set(value, (freq.get(value) || 0) + 1);
7  }
8
9  for (const value of b) {
10    if (!freq.has(value)) return false;
11    const next = freq.get(value) - 1;
12    if (next === 0) freq.delete(value);
13    else freq.set(value, next);
14  }
15
16  return freq.size === 0;
17}
18
19console.log(sameMultiset([1, 2, 2], [2, 1, 2]));

Sorting-Based Comparison

Sorting is concise when elements are comparable and arrays are not huge.

1def same_by_sorting(a, b):
2    return len(a) == len(b) and sorted(a) == sorted(b)
3
4
5print(same_by_sorting([5, 1, 5], [1, 5, 5]))

Sorting works well for primitive values, but it may fail for mixed incomparable types or become less attractive when arrays are large and element cardinality is low.

In JavaScript, remember that default sort is lexicographic, not numeric.

const a = [10, 2, 1];
console.log([...a].sort((x, y) => x - y));

Without the comparator, numeric comparisons can be wrong.

Arrays of Objects Need Canonicalization

For arrays of objects, you usually need a stable representation before counting or sorting.

1import json
2from collections import Counter
3
4
5def canonical(obj):
6    return json.dumps(obj, sort_keys=True, separators=(",", ":"))
7
8
9def same_object_multiset(a, b):
10    return Counter(canonical(x) for x in a) == Counter(canonical(x) for x in b)
11
12
13left = [{"id": 1, "name": "A"}, {"id": 2, "name": "B"}]
14right = [{"name": "B", "id": 2}, {"name": "A", "id": 1}]
15print(same_object_multiset(left, right))

Canonicalization removes noise such as dictionary key order and lets you compare the logical content instead.

Performance Considerations

Choose the method based on the input profile:

• sorting is simple and often fast for moderate arrays
• counting is attractive when duplicates matter and you want linear-time behavior on average
• object canonicalization adds serialization cost and should be used deliberately

The fastest-looking approach on tiny toy arrays is not always the best choice for production-sized data.

Common Pitfalls

A common mistake is using set equality when duplicate counts actually matter. That silently accepts invalid data.

Another issue is forgetting a numeric comparator in JavaScript sorting and getting lexicographic ordering instead.

Developers also sometimes compare objects directly even though property order or formatting differences make raw equality unstable.

Finally, if the comparison rule is business-specific, document it. “Same elements” is often not precise enough on its own.

Summary

• Decide first whether you need set equality, multiset equality, or normalized object equality.
• Use frequency counting when duplicate counts matter.
• Use sorting when elements are comparable and the simpler code is worth it.
• Canonicalize objects before unordered comparison.
• The algorithm is only correct if the equality semantics are correct.