{"id":176,"date":"2024-01-04T09:25:59","date_gmt":"2024-01-04T09:25:59","guid":{"rendered":"https:\/\/www.kaashivinfotech.com\/blog\/?p=176"},"modified":"2025-07-23T10:48:35","modified_gmt":"2025-07-23T10:48:35","slug":"remove-duplicates-from-array","status":"publish","type":"post","link":"https:\/\/www.kaashivinfotech.com\/blog\/remove-duplicates-from-array\/","title":{"rendered":"How to Remove Duplicates from Array in 2025 \ud83e\udde0 | 5 Easy Methods with Code Examples"},"content":{"rendered":"

Why Removing Duplicate Elements from an Array Matters in 2025<\/strong><\/h2>\n

In programming, one of the most common challenges is how to remove duplicate elements from an array<\/strong> while preserving the original order and ensuring optimal performance. Whether you’re a beginner working on your first algorithm or a developer handling large-scale data, removing duplicates is essential for clean, efficient code. This guide covers multiple methods to remove duplicates from arrays<\/strong>, including techniques that use extra space like hash maps and sets, as well as in-place solutions that work without additional memory. We\u2019ll also provide code examples in C++, Java, and Python<\/strong>, making it easy for you to implement in your preferred language.<\/p>\n

\n

\ud83d\udd0d Problem Statement: How to Remove the Duplicate Elements in Array<\/strong> Efficiently<\/h2>\n

Given an array of elements, write a program or function to remove any duplicate elements from the array, ensuring that each element appears only once in the resulting array. The goal is to modify the array in place, so that no additional data structures are used, and the order of the unique elements is preserved.<\/p>\n

\n

Method \u2013 1 (Using Sorting)<\/strong><\/h2>\n

One way to remove duplicates from an array is to sort the array first and then iterate through it, removing duplicate elements as you encounter them. Sorting the array ensures that duplicate elements are adjacent to each other, making them easy to identify and remove during the iteration.<\/p>\n

Solution 1 (Using extra space)<\/strong><\/h3>\n

In this approach, we use a hash set or dictionary (depending on the programming language) to keep track of elements that we have already seen in the input array. We iterate through the input array, and for each element, we check whether it has been seen before. If it hasn’t been seen, we add it to the result array and mark it as seen in the hash set. If it has been seen, we skip it as it’s a duplicate.<\/p>\n

C++ Code<\/strong><\/h4>\n
#include <iostream>#include <unordered_set>#include <vector>std::vector<int> removeDuplicates(std::vector<int>& arr) {std::unordered_set<int> seen;std::vector<int> result;for (int num : arr) {if (seen.find(num) == seen.end()) {seen.insert(num);result.push_back(num);}}return result;}int main() {std::vector<int> inputArr = {3, 1, 2, 2, 1, 3, 5};std::vector<int> result = removeDuplicates(inputArr);for (int num : result) {std::cout << num << " ";}return 0;}<\/code><\/pre> 
 <\/div> <\/div>\n
Java Code<\/strong><\/h4>\n
 
import java.util.ArrayList;import java.util.HashSet;import java.util.List;import java.util.Set;public class RemoveDuplicatesFromArray {public static List<Integer> removeDuplicates(List<Integer> arr) {Set<Integer> seen = new HashSet<>();List<Integer> result = new ArrayList<>();for (int num : arr) {if (!seen.contains(num)) {seen.add(num);result.add(num);}}return result;}public static void main(String[] args) {List<Integer> inputArr = List.of(3, 1, 2, 2, 1, 3, 5);List<Integer> result = removeDuplicates(inputArr);for (int num : result) {System.out.print(num + " ");}}}<\/code><\/pre> 
 <\/div> <\/div>\n
Python Code<\/strong><\/h4>\n
 
def remove_duplicates(arr):seen = set()result = []for num in arr:if num not in seen:seen.add(num)result.append(num)return result# Example usageinput_arr = [3, 1, 2, 2, 1, 3, 5]result = remove_duplicates(input_arr)print(result)\u00a0 # Output: [3, 1, 2, 5]<\/code><\/pre> 
 <\/div> <\/div>\n
Solution 2 (Without using extra space)<\/strong><\/h3>\n
In this approach, we aim to remove duplicates from the array without using additional data structures like sets or dictionaries. Instead, we modify the original array in place. The key idea is to maintain two pointers, one for iterating through the array and another for placing unique elements in their correct positions in the array.<\/p>\n
C++ Code<\/strong><\/h4>\n
 
#include <iostream>#include <vector>std::vector<int> removeDuplicates(std::vector<int>& arr) {if (arr.empty()) {return {};}int n = arr.size();int uniqueIndex = 0; \/\/ Index to track unique elementsfor (int i = 1; i < n; ++i) {bool isDuplicate = false;\/\/ Check if the current element is a duplicatefor (int j = 0; j <= uniqueIndex; ++j) {if (arr[i] == arr[j]) {isDuplicate = true;break;}}\/\/ If it's not a duplicate, move it to the next unique positionif (!isDuplicate) {++uniqueIndex;arr[uniqueIndex] = arr[i];}}\/\/ Resize the array to the number of unique elementsarr.resize(uniqueIndex + 1);return arr;}int main() {std::vector<int> inputArr = {3, 1, 2, 2, 1, 3, 5};std::vector<int> result = removeDuplicates(inputArr);for (int num : result) {std::cout << num << " ";}return 0;}<\/code><\/pre> 
 <\/div> <\/div>\n
Java Code<\/strong><\/h4>\n
 
import java.util.ArrayList;import java.util.List;public class RemoveDuplicatesFromArray {public static List<Integer> removeDuplicates(List<Integer> arr) {if (arr.isEmpty()) {return new ArrayList<>();}int n = arr.size();int uniqueIndex = 0; \/\/ Index to track unique elementsfor (int i = 1; i < n; ++i) {boolean isDuplicate = false;\/\/ Check if the current element is a duplicatefor (int j = 0; j <= uniqueIndex; ++j) {if (arr.get(i).equals(arr.get(j))) {isDuplicate = true;break;}}\/\/ If it's not a duplicate, move it to the next unique positionif (!isDuplicate) {++uniqueIndex;arr.set(uniqueIndex, arr.get(i));}}\/\/ Remove excess elements to keep only unique elementsarr.subList(uniqueIndex + 1, n).clear();return arr.subList(0, uniqueIndex + 1);}public static void main(String[] args) {List<Integer> inputArr = List.of(3, 1, 2, 2, 1, 3, 5);List<Integer> result = removeDuplicates(inputArr);for (int num : result) {System.out.print(num + " ");}}}<\/code><\/pre> 
 <\/div> <\/div>\n
Python code<\/strong><\/h4>\n
 
def remove_duplicates(arr):if not arr:return []n = len(arr)unique_index = 0\u00a0 # Index to track unique elementsfor i in range(1, n):is_duplicate = False# Check if the current element is a duplicatefor j in range(0, unique_index + 1):if arr[i] == arr[j]:is_duplicate = Truebreak# If it's not a duplicate, move it to the next unique positionif not is_duplicate:unique_index += 1arr[unique_index] = arr[i]# Slice the array to keep only unique elementsreturn arr[:unique_index + 1]# Example usage:input_arr = [3, 1, 2, 2, 1, 3, 5]result = remove_duplicates(input_arr)print(result)\u00a0 # Output: [3, 1, 2, 5]<\/code><\/pre> 
 <\/div> <\/div>\n
Method \u2013 2 (Use of HashMaps)<\/strong><\/h2>\n
In this approach, we utilize a hash map (unordered_map in C++, HashMap in Java, and dictionaries in Python) to keep track of the frequency of each element in the array. We iterate through the array, and for each element, we check if it has been encountered before. If it hasn’t, we add it to the hash map with a frequency count of 1. If it has been encountered, we skip it as it’s a duplicate.<\/p>\n
C++ Code (Using unordered_map)<\/strong><\/h3>\n
 
#include <iostream>#include <vector>#include <unordered_map>std::vector<int> removeDuplicates(std::vector<int>& arr) {std::unordered_map<int, int> freqMap;std::vector<int> result;for (int num : arr) {if (freqMap.find(num) == freqMap.end()) {freqMap[num] = 1; \/\/ Add to map if not seen beforeresult.push_back(num);}}return result;}int main() {std::vector<int> inputArr = {3, 1, 2, 2, 1, 3, 5};std::vector<int> result = removeDuplicates(inputArr);for (int num : result) {std::cout << num << " ";}return 0;}<\/code><\/pre> 
 <\/div> <\/div>\n
Java Code (Using HashMap)<\/strong><\/h3>\n
 
import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;public class RemoveDuplicatesFromArray {public static List<Integer> removeDuplicates(List<Integer> arr) {Map<Integer, Integer> freqMap = new HashMap<>();List<Integer> result = new ArrayList<>();for (int num : arr) {if (!freqMap.containsKey(num)) {freqMap.put(num, 1); \/\/ Add to map if not seen beforeresult.add(num);}}return result;}public static void main(String[] args) {List<Integer> inputArr = List.of(3, 1, 2, 2, 1, 3, 5);List<Integer> result = removeDuplicates(inputArr);for (int num : result) {System.out.print(num + " ");}}}<\/code><\/pre> 
 <\/div> <\/div>\n
Python Code (Using dictionaries)<\/strong><\/h3>\n
 
def remove_duplicates(arr):freq_map = {}result = []for num in arr:if num not in freq_map:freq_map[num] = 1\u00a0 # Add to dictionary if not seen beforeresult.append(num)return result# Example usage:input_arr = [3, 1, 2, 2, 1, 3, 5]result = remove_duplicates(input_arr)print(result)\u00a0 # Output: [3, 1, 2, 5]<\/code><\/pre> 
 <\/div> <\/div>\n
\"Remove<\/p>\n
\n
FAQS<\/strong><\/h2>\n
1.Why do we need to remove duplicates from an array?<\/strong><\/h3>\n
Removing duplicates from an array is often necessary to ensure data integrity, improve efficiency in data processing, and simplify data analysis. It’s commonly used in various programming tasks and applications.<\/p>\n
2.What are the different methods to remove duplicates from an array?<\/strong><\/h3>\n
There are several methods to remove duplicates from an array, including using hash maps, sorting and iterating, using sets or linked lists, or employing in-place techniques.<\/p>\n
3.What is the time complexity of removing duplicates from an array using hash maps?<\/strong><\/h3>\n
The time complexity for removing duplicates using hash maps is typically O(n), where n is the number of elements in the array. This is because hash maps allow constant-time (O(1)) average complexity for insertion and retrieval.<\/p>\n
4.How can duplicates be removed from an array without using extra space?<\/strong><\/h3>\n
Duplicates can be removed from an array without using extra space by employing in-place techniques. One common approach is to sort the array first and then iterate through it to remove duplicates in a single pass.<\/p>\n
5.Is the order of elements preserved when removing duplicates from an array?<\/strong><\/h3>\n
The order of elements can be preserved or not, depending on the specific method used to remove duplicates. Hash map-based methods typically preserve the order, while sorting-based methods may not.<\/p>\n
\n
Conclusion: Best Ways to Remove Duplicate Elements from Array<\/strong><\/h2>\n
In modern coding, knowing how to remove duplicate elements from array<\/strong> structures is essential. Clean, duplicate-free arrays are key to better performance, simplified logic, and bug-free code. You\u2019ve learned multiple ways to remove the duplicate elements in array<\/strong>, from using sets and loops to advanced array methods. No matter the language\u2014JavaScript, Python, or others\u2014choosing the right method to remove duplicate elements from array<\/strong> ensures your program stays fast and efficient. Keep experimenting with these techniques, and you\u2019ll never struggle with messy data again.<\/p>\n
\n
\ud83d\udcda Related Reads<\/h3>\n