Find the only non-repeating element in a given array
Last Updated :
04 Nov, 2023
Improve
Given an array A[] consisting of N (1 ? N ? 105) positive integers, the task is to find the only array element with a single occurrence.
Note: It is guaranteed that only one such element exists in the array.
Examples:
Input: A[] = {1, 1, 2, 3, 3}
Output: 2
Explanation:
Distinct array elements are {1, 2, 3}.
Frequency of these elements are {2, 1, 2} respectively.Input : A[] = {1, 1, 1, 2, 2, 3, 5, 3, 4, 4}
Output : 5
Approach: Follow the steps below to solve the problem
- Traverse the array
- Use an Unordered Map to store the frequency of array elements.
- Traverse the Map and find the element with frequency 1 and print that element.
Below is the implementation of the above approach:
// C++ implementation of the
// above approach
#include <bits/stdc++.h>
using namespace std;
// Function call to find
// element in A[] with frequency = 1
void CalcUnique(int A[], int N)
{
// Stores frequency of
// array elements
unordered_map<int, int> freq;
// Traverse the array
for (int i = 0; i < N; i++) {
// Update frequency of A[i]
freq[A[i]]++;
}
// Traverse the Map
for (int i = 0; i < N; i++) {
// If non-repeating element
// is found
if (freq[A[i]] == 1) {
cout << A[i];
return;
}
}
}
// Driver Code
int main()
{
int A[] = { 1, 1, 2, 3, 3 };
int N = sizeof(A) / sizeof(A[0]);
CalcUnique(A, N);
return 0;
}
// C++ implementation of the// above approachusing namespace std;// Function call to find// element in A[] with frequency = 1void CalcUnique(int A[], int N){ // Stores frequency of // array elements unordered_map<int, int> freq; // Traverse the array for (int i = 0; i < N; i++) { // Update frequency of A[i] freq[A[i]]++; } // Traverse the Map for (int i = 0; i < N; i++) { // If non-repeating element // is found if (freq[A[i]] == 1) { cout << A[i]; return; } }}// Driver Codeint main(){ int A[] = { 1, 1, 2, 3, 3 }; int N = sizeof(A) / sizeof(A[0]); CalcUnique(A, N); return 0;}// Java implementation of the
// above approach
import java.util.*;
class GFG
{
// Function call to find
// element in A[] with frequency = 1
static void CalcUnique(int A[], int N)
{
// Stores frequency of
// array elements
HashMap<Integer,Integer> freq = new HashMap<Integer,Integer>();
// Traverse the array
for (int i = 0; i < N; i++)
{
// Update frequency of A[i]
if(freq.containsKey(A[i]))
{
freq.put(A[i], freq.get(A[i]) + 1);
}
else
{
freq.put(A[i], 1);
}
}
// Traverse the Map
for (int i = 0; i < N; i++)
{
// If non-repeating element
// is found
if (freq.containsKey(A[i])&&freq.get(A[i]) == 1)
{
System.out.print(A[i]);
return;
}
}
}
// Driver Code
public static void main(String[] args)
{
int A[] = { 1, 1, 2, 3, 3 };
int N = A.length;
CalcUnique(A, N);
}
}
// This code is contributed by 29AjayKumar
# Python 3 implementation of the
# above approach
from collections import defaultdict
# Function call to find
# element in A[] with frequency = 1
def CalcUnique(A, N):
# Stores frequency of
# array elements
freq = defaultdict(int)
# Traverse the array
for i in range(N):
# Update frequency of A[i]
freq[A[i]] += 1
# Traverse the Map
for i in range(N):
# If non-repeating element
# is found
if (freq[A[i]] == 1):
print(A[i])
return
# Driver Code
if __name__ == "__main__":
A = [1, 1, 2, 3, 3]
N = len(A)
CalcUnique(A, N)
# This code is contributed by chitranayal.
// C# implementation of the
// above approach
using System;
using System.Collections.Generic;
public class GFG
{
// Function call to find
// element in []A with frequency = 1
static void CalcUnique(int []A, int N)
{
// Stores frequency of
// array elements
Dictionary<int,int> freq = new Dictionary<int,int>();
// Traverse the array
for (int i = 0; i < N; i++)
{
// Update frequency of A[i]
if(freq.ContainsKey(A[i]))
{
freq[A[i]] = freq[A[i]] + 1;
}
else
{
freq.Add(A[i], 1);
}
}
// Traverse the Map
for (int i = 0; i < N; i++)
{
// If non-repeating element
// is found
if (freq.ContainsKey(A[i]) && freq[A[i]] == 1)
{
Console.Write(A[i]);
return;
}
}
}
// Driver Code
public static void Main(String[] args)
{
int []A = { 1, 1, 2, 3, 3 };
int N = A.Length;
CalcUnique(A, N);
}
}
// This code is contributed by 29AjayKumar
<script>
// JavaScript implementation of the
// above approach
// Function call to find
// element in A[] with frequency = 1
function CalcUnique(A, N)
{
// Stores frequency of
// array elements
var freq = new Map();
// Traverse the array
for (var i = 0; i < N; i++) {
// Update frequency of A[i]
if(freq.has(A[i]))
{
freq.set(A[i], freq.get(A[i])+1);
}
else
{
freq.set(A[i],1);
}
}
// Traverse the Map
for (var i = 0; i < N; i++) {
// If non-repeating element
// is found
if (freq.get(A[i]) == 1) {
document.write( A[i]);
return;
}
}
}
// Driver Code
var A = [1, 1, 2, 3, 3 ];
var N = A.length;
CalcUnique(A, N);
</script>
Output
2
Time Complexity : O(N)
Auxiliary Space : O(N)
Another Approach: Using Built-in Functions:
- Calculate the frequencies using Built-In function.
- Traverse the array and find the element with frequency 1 and print it.
Below is the implementation:
#include <iostream>
#include <unordered_map>
using namespace std;
// Function call to find element in A[] with frequency = 1
void CalcUnique(int A[], int N)
{
// Calculate frequency of all array elements
unordered_map<int, int> freq;
// Traverse the Array
for (int i = 0; i < N; i++)
{
// Update frequency of each array element in the map
int count = 1;
if (freq.count(A[i])) {
count = freq[A[i]];
count++;
}
freq[A[i]] = count;
}
// Traverse the Array
for (int i = 0; i < N; i++)
{
// If non-repeating element is found
if (freq[A[i]] == 1) {
cout << A[i] << endl;
return;
}
}
}
// Driver Code
int main()
{
int A[] = { 1, 1, 2, 3, 3 };
int N = sizeof(A) / sizeof(A[0]);
CalcUnique(A, N);
return 0;
}
using namespace std;// Function call to find element in A[] with frequency = 1void CalcUnique(int A[], int N){ // Calculate frequency of all array elements unordered_map<int, int> freq; // Traverse the Array for (int i = 0; i < N; i++) { // Update frequency of each array element in the map int count = 1; if (freq.count(A[i])) { count = freq[A[i]]; count++; } freq[A[i]] = count; } // Traverse the Array for (int i = 0; i < N; i++) { // If non-repeating element is found if (freq[A[i]] == 1) { cout << A[i] << endl; return; } }}// Driver Codeint main(){ int A[] = { 1, 1, 2, 3, 3 }; int N = sizeof(A) / sizeof(A[0]); CalcUnique(A, N); return 0;}//Java code:
import java.util.Map;
import java.util.HashMap;
class Main{
// Function call to find
// element in A[] with frequency = 1
public static void CalcUnique(int A[], int N)
{
// Calculate frequency of
// all array elements
Map<Integer, Integer> freq = new HashMap<Integer, Integer>();
// Traverse the Array
for (int i=0; i<N; i++)
{
// Update frequency of each
// array element in the map
int count = 1;
if(freq.containsKey(A[i]))
{
count = freq.get(A[i]);
count++;
}
freq.put(A[i], count);
}
// Traverse the Array
for (int i=0; i<N; i++)
{
// If non-repeating element
// is found
if (freq.get(A[i]) == 1)
{
System.out.println(A[i]);
return;
}
}
}
// Driver Code
public static void main(String args[])
{
int A[] = {1, 1, 2, 3, 3};
int N = A.length;
CalcUnique(A, N);
}}
# Python 3 implementation of the
# above approach
from collections import Counter
# Function call to find
# element in A[] with frequency = 1
def CalcUnique(A, N):
# Calculate frequency of
# all array elements
freq = Counter(A)
# Traverse the Array
for i in A:
# If non-repeating element
# is found
if (freq[i] == 1):
print(i)
return
# Driver Code
if __name__ == "__main__":
A = [1, 1, 2, 3, 3]
N = len(A)
CalcUnique(A, N)
# This code is contributed by vikkycirus
using System;
using System.Collections.Generic;
public class MainClass {
// Function call to find element in A[] with frequency =
// 1
static void CalcUnique(int[] A, int N)
{
// Calculate frequency of all array elements
Dictionary<int, int> freq
= new Dictionary<int, int>();
// Traverse the Array
for (int i = 0; i < N; i++) {
// Update frequency of each array element in the
// dictionary
if (freq.ContainsKey(A[i])) {
freq[A[i]]++;
}
else {
freq[A[i]] = 1;
}
}
// Traverse the Array
for (int i = 0; i < N; i++) {
// If non-repeating element is found
if (freq[A[i]] == 1) {
Console.WriteLine(A[i]);
return;
}
}
}
// Driver Code
public static void Main()
{
int[] A = { 1, 1, 2, 3, 3 };
int N = A.Length;
CalcUnique(A, N);
}
}
<script>
// Function call to find
// element in A[] with frequency = 1
function CalcUnique(A) {
// Calculate frequency of
// all array elements
let freq = A.reduce((acc, curr) => {
if (acc[curr]) {
acc[curr]++;
} else {
acc[curr] = 1;
}
return acc;
}, {});
// Traverse the Array
for (let i = 0; i < A.length; i++) {
// If non-repeating element
// is found
if (freq[A[i]] === 1) {
console.log(A[i]);
return;
}
}
}
// Driver Code
const A = [1, 1, 2, 3, 3];
CalcUnique(A);
</script>
Output
2
Time Complexity: O(N)
Auxiliary Space: O(N)
Another Approach: Using Sorting
The idea is to sort the array and find which element occurs only once by traversing the array.
Steps to implement this Approach-
- Sort the given array
- Then traverse from starting to the end of the array
- Since the array is already sorted that's why repeating element will be consecutive
- So in that whole array, we will find which element occurred only once. That is our required answer
Code-
#include <bits/stdc++.h>
using namespace std;
// Function call to find single non-repeating element
void CalcUnique(int arr[], int N)
{
//Sort the Array
sort(arr,arr+N);
int temp=INT_MIN;
int count=0;
// Traverse the Array
for(int i=0;i<N;i++){
if(arr[i]==temp){count++;}
else{
if(count==1){
cout<<temp<<endl;
return;
}
temp=arr[i];
count=1;
}
}
//If yet not returned from the function then last element is the only non-repeating element
cout<<arr[N-1]<<endl;
}
// Driver Code
int main()
{
int arr[] = {1, 1, 2, 3, 3};
int N = sizeof(arr) / sizeof(arr[0]);
CalcUnique(arr, N);
return 0;
}
using namespace std;// Function call to find single non-repeating elementvoid CalcUnique(int arr[], int N){ //Sort the Array sort(arr,arr+N);int temp=INT_MIN;int count=0; // Traverse the Array for(int i=0;i<N;i++){ if(arr[i]==temp){count++;} else{ if(count==1){ cout<<temp<<endl; return; } temp=arr[i]; count=1; } } //If yet not returned from the function then last element is the only non-repeating element cout<<arr[N-1]<<endl; }// Driver Codeint main(){ int arr[] = {1, 1, 2, 3, 3}; int N = sizeof(arr) / sizeof(arr[0]); CalcUnique(arr, N); return 0;}import java.util.*;
public class Main {
// Function call to find single non-repeating element
public static void CalcUnique(int[] arr, int N) {
// Sort the Array
Arrays.sort(arr);
int temp=Integer.MIN_VALUE;
int count=0;
// Traverse the Array
for(int i=0;i<N;i++){
if(arr[i]==temp){
count++;
} else {
if(count==1){
System.out.println(temp);
return;
}
temp=arr[i];
count=1;
}
}
// If yet not returned from the function then last element is the only non-repeating element
System.out.println(arr[N-1]);
}
// Driver Code
public static void main(String[] args) {
int[] arr = {1, 1, 2, 3, 3};
int N = arr.length;
CalcUnique(arr, N);
}
}
def calc_unique(arr, N):
# Sort the array
arr.sort()
temp = None
count = 0
# Traverse the array
for i in range(N):
if arr[i] == temp:
count += 1
else:
if count == 1:
print(temp)
return
temp = arr[i]
count = 1
# If yet not returned from the function,
# then the last element is the only non-repeating element
print(arr[N-1])
# Driver Code
if __name__ == "__main__":
arr = [1, 1, 2, 3, 3]
N = len(arr)
calc_unique(arr, N)
using System;
using System.Linq;
class Program
{
// Function to find the single non-repeating element
static void CalcUnique(int[] arr, int N)
{
// Sort the array
Array.Sort(arr);
int temp = int.MinValue;
int count = 0;
for (int i = 0; i < N; i++)
{
// If the current element is equal to the previous element, increase the count
if (arr[i] == temp)
{
count++;
}
else
{
// If the count is 1, it means the previous element is the non-repeating element
if (count == 1)
{
Console.WriteLine(temp);
return;
}
// Update the current element and reset the count
temp = arr[i];
count = 1;
}
}
// If not returned from the function, then the last element is the only non-repeating element
Console.WriteLine(arr[N - 1]);
}
static void Main(string[] args)
{
int[] arr = { 1, 1, 2, 3, 3 };
int N = arr.Length;
CalcUnique(arr, N);
}
}
// Function to find single non-repeating element
function calcUnique(arr) {
// Sort the Array
arr.sort((a, b) => a - b);
let temp = Number.MIN_SAFE_INTEGER;
let count = 0;
// Traverse the Array
for(let i = 0; i < arr.length; i++) {
if(arr[i] === temp) {
count++;
} else {
if(count === 1) {
console.log(temp);
return;
}
temp = arr[i];
count = 1;
}
}
// If not returned from the function yet, then the last element is the only non-repeating element
console.log(arr[arr.length - 1]);
}
// Driver Code
const arr = [1, 1, 2, 3, 3];
calcUnique(arr);
Output
2
Time Complexity: O(NlogN)+O(N)=O(NlogN), O(NlogN) in sorting and O(N) in traversing the array
Auxiliary Space: O(1), because no extra space has been taken
