.png)
Find All Unique Elements in an Array
Problem Statement
Given an array of n elements, find all the unique elements.
- A unique element is an element that appears exactly once in the array.
- Arrays may contain positive, negative, or zero values.
- The goal is to output all elements that do not repeat.
Example 1
Input:
arr = [1, 2, 2, 3, 4, 4, 5]
Output:
[1, 3, 5]
Explanation:
- 1 appears once → unique
- 2 appears twice → not unique
- 3 appears once → unique
- 4 appears twice → not unique
- 5 appears once → unique
Example 2
Input:
arr = [7, 7, 8, 9, 10, 9]
Output:
[8, 10]
Explanation:
- 8 and 10 appear only once → unique elements
Why This Problem Is Important
- Tests array traversal, hashing, and frequency counting.
- Foundation for duplicate detection, data cleaning, and analytics.
- Helps prepare for interview questions on arrays and hash tables.
Approaches to Solve the Problem
- Using Hash Map / Dictionary (Efficient) ✅
- Using Sorting (Alternative) ✅
- Brute Force (Nested Loops, Not Recommended)
Approach 1: Using Hash Map / Dictionary
Idea
- Traverse the array and maintain a frequency map.
- For each element, increase its count.
- After building the map, select all elements with count = 1 as unique elements.
Time & Space Complexity
- Time Complexity: O(n)
- Space Complexity: O(n)
Python Implementation
arr = [1, 2, 2, 3, 4, 4, 5]
freq = {}
# Count frequency
for num in arr:
freq[num] = freq.get(num, 0) + 1
# Extract unique elements
unique_elements = [num for num, count in freq.items() if count == 1]
print("Unique elements:", unique_elements)
Output:
Unique elements: [1, 3, 5]
C++ Implementation
#include
#include
#include
using namespace std;
int main() {
vector arr = {1, 2, 2, 3, 4, 4, 5};
unordered_map freq;
for(int num : arr) freq[num]++;
cout << "Unique elements: ";
for(auto it : freq)
if(it.second == 1) cout << it.first << " ";
}
Java Implementation
import java.util.*;
public class UniqueElements {
public static void main(String[] args) {
int[] arr = {1, 2, 2, 3, 4, 4, 5};
HashMap freq = new HashMap<>();
for(int num : arr)
freq.put(num, freq.getOrDefault(num, 0) + 1);
System.out.print("Unique elements: ");
for(int key : freq.keySet())
if(freq.get(key) == 1) System.out.print(key + " ");
}
}
C# Implementation
using System;
using System.Collections.Generic;
class Program {
static void Main() {
int[] arr = {1, 2, 2, 3, 4, 4, 5};
Dictionary freq = new Dictionary();
foreach(int num in arr)
freq[num] = freq.GetValueOrDefault(num,0) + 1;
Console.Write("Unique elements: ");
foreach(var kvp in freq)
if(kvp.Value == 1) Console.Write(kvp.Key + " ");
}
}
JavaScript Implementation
let arr = [1, 2, 2, 3, 4, 4, 5];
let freq = {};
arr.forEach(num => freq[num] = (freq[num] || 0) + 1);
let unique = [];
for(let key in freq){
if(freq[key] == 1) unique.push(Number(key));
}
console.log("Unique elements:", unique);
Approach 2: Using Sorting
Idea
- Sort the array.
- Compare each element with its previous and next element.
- If the element is different from both neighbors (or boundary), it is unique.
- In-place option, O(n log n) time.
Python Implementation
arr = [1, 2, 2, 3, 4, 4, 5]
arr.sort()
n = len(arr)
unique_elements = []
for i in range(n):
if (i == 0 or arr[i] != arr[i-1]) and (i == n-1 or arr[i] != arr[i+1]):
unique_elements.append(arr[i])
print("Unique elements:", unique_elements)
C++ Implementation
#include
#include
#include
using namespace std;
int main() {
vector arr = {1, 2, 2, 3, 4, 4, 5};
sort(arr.begin(), arr.end());
vector unique_elements;
int n = arr.size();
for(int i = 0; i < n; i++){
if((i == 0 || arr[i] != arr[i-1]) && (i == n-1 || arr[i] != arr[i+1])){
unique_elements.push_back(arr[i]);
}
}
cout << "Unique elements: ";
for(int num : unique_elements) cout << num << " ";
}
Java Implementation
import java.util.*;
public class UniqueElementsSorting {
public static void main(String[] args) {
int[] arr = {1, 2, 2, 3, 4, 4, 5};
Arrays.sort(arr);
ArrayList unique_elements = new ArrayList<>();
int n = arr.length;
for(int i = 0; i < n; i++){
if((i == 0 || arr[i] != arr[i-1]) && (i == n-1 || arr[i] != arr[i+1])){
unique_elements.add(arr[i]);
}
}
System.out.print("Unique elements: ");
for(int num : unique_elements) System.out.print(num + " ");
}
}
C# Implementation
using System;
using System.Collections.Generic;
class Program {
static void Main() {
int[] arr = {1, 2, 2, 3, 4, 4, 5};
Array.Sort(arr);
List unique_elements = new List();
int n = arr.Length;
for(int i = 0; i < n; i++){
if((i == 0 || arr[i] != arr[i-1]) && (i == n-1 || arr[i] != arr[i+1])){
unique_elements.Add(arr[i]);
}
}
Console.Write("Unique elements: ");
foreach(int num in unique_elements) Console.Write(num + " ");
}
}
JavaScript Implementation
let arr = [1, 2, 2, 3, 4, 4, 5];
arr.sort((a,b) => a-b); // numeric sort
let unique_elements = [];
let n = arr.length;
for(let i = 0; i < n; i++){
if((i === 0 || arr[i] !== arr[i-1]) && (i === n-1 || arr[i] !== arr[i+1])){
unique_elements.push(arr[i]);
}
}
console.log("Unique elements:", unique_elements);
Approach 3: Brute Force (Nested Loops)
Idea
- For each element, traverse the array and count its occurrences.
- If count = 1, add it to the unique list.
- Simple but inefficient, O(n²) time.
Python Implementation
arr = [1, 2, 2, 3, 4, 4, 5]
n = len(arr)
unique_elements = []
for i in range(n):
count = 0
for j in range(n):
if arr[i] == arr[j]:
count += 1
if count == 1:
unique_elements.append(arr[i])
print("Unique elements:", unique_elements)
C++ Implementation
#include
#include
using namespace std;
int main() {
vector arr = {1, 2, 2, 3, 4, 4, 5};
vector unique_elements;
int n = arr.size();
for(int i = 0; i < n; i++){
int count = 0;
for(int j = 0; j < n; j++){
if(arr[i] == arr[j]) count++;
}
if(count == 1) unique_elements.push_back(arr[i]);
}
cout << "Unique elements: ";
for(int num : unique_elements) cout << num << " ";
}
Java Implementation
import java.util.*;
public class UniqueElementsBruteForce {
public static void main(String[] args) {
int[] arr = {1, 2, 2, 3, 4, 4, 5};
int n = arr.length;
ArrayList unique_elements = new ArrayList<>();
for(int i = 0; i < n; i++){
int count = 0;
for(int j = 0; j < n; j++){
if(arr[i] == arr[j]) count++;
}
if(count == 1) unique_elements.add(arr[i]);
}
System.out.print("Unique elements: ");
for(int num : unique_elements) System.out.print(num + " ");
}
}
C# Implementation
using System;
using System.Collections.Generic;
class Program {
static void Main() {
int[] arr = {1, 2, 2, 3, 4, 4, 5};
int n = arr.Length;
List unique_elements = new List();
for(int i = 0; i < n; i++){
int count = 0;
for(int j = 0; j < n; j++){
if(arr[i] == arr[j]) count++;
}
if(count == 1) unique_elements.Add(arr[i]);
}
Console.Write("Unique elements: ");
foreach(int num in unique_elements) Console.Write(num + " ");
}
}
JavaScript Implementation
let arr = [1, 2, 2, 3, 4, 4, 5];
let unique_elements = [];
let n = arr.length;
for(let i = 0; i < n; i++){
let count = 0;
for(let j = 0; j < n; j++){
if(arr[i] === arr[j]) count++;
}
if(count === 1) unique_elements.push(arr[i]);
}
console.log("Unique elements:", unique_elements);
✅ Summary of Approaches for Finding Unique Elements
| Approach | Time Complexity | Space Complexity | Notes |
|---|---|---|---|
| Hash Map / Dictionary | O(n) | O(n) | Efficient, recommended |
| Sorting | O(n log n) | O(1) extra | In-place, array gets sorted |
| Brute Force | O(n²) | O(1) extra | Simple but slow |
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
