# How to Return Recurring Elements in a Javascript Array With O(n) Time Complexity

Hello there!

In this article, I’ll be showing you how to return recurring elements in a Javascript Array WIth O(n) Time complexity.

First, I’ll be showing you the wrong way to do it, then the correct way.

Let’s consider the given array;

```
const numbers = [1, 3, 2, 1, 2, 3, 4, 5, 6, 4];
```

### METHOD 1

```
const findDuplicates = (arr) => {
const duplicates = [];
arr.forEach((number, index) => {
if (index !== arr.lastIndexOf(number)) {
duplicates.push(number);
}
});
return duplicates;
};
//findDuplicates(numbers) will return [ 1, 2, 3, 4, 6 ]
```

In as much as this is the quickest method one can think of, under the hood has a nested loop which in turn returns an O(n)^2 time complexity.

So we move on to method 2.

### METHOD 2

In the second method, we’ll be using something called a hashMap. A hashMap is a data structure that allows us to store key-value pairs and we can use non-primitive datatype to store the data.

The Map will return the key and value pairs in the same order we inserted and it retrieves this in O(n) time-complexity.

So our second solution will look like this;

```
const findDuplicates = (arr) => {
const duplicates = [];
const map = new Map();
arr.forEach((number) => {
if (map.get(number)) {
duplicates.push(number);
} else {
map.set(number, number);
}
});
return duplicates;
};
//findDuplicates(numbers) will return [ 1, 2, 3, 4, 6 ]
```

I do hope you’ve found this helpful, Thanks.