I have an array elements like this:
int arr[] = {1,1,2,2,3,3,4,4};
I want to remove the duplicate elements from. Searched on the internet and came to know about ArrayUtil class. Could you please help me by telling it's usage - that's how can I get an array like this in output:
arr[] = {1,2,3,4};
This is the next step from Element Distinctness Problem, which is discussed thoroughly in this thread: Find duplicates in an array, including lower bounds for the problem (cannot do better than O(nlogn) without a hash set involved).
If you are unwilling to use a hash-set to check out all the elements you have already seen, your best bet is to sort the array, and then iterate it - all duplicate elements will be adjacent to each other.
public static int[] justUniques(int[] arr) {
if (arr == null || arr.length == 0) return arr;
Arrays.sort(arr);
int n = 1;
for (int i = 1; i < arr.length; i++) {
if (arr[i] != arr[i-1]) n++;
}
int[] res = new int[n];
res[0] = arr[0];
n = 1;
for (int i = 1; i < arr.length; i++) {
if (arr[i] != arr[i-1]) res[n++] = arr[i];
}
return res;
}
Note that a simple variation of the above can also do it in-place, without creating a new array.
This solution is O(nlogn), and thus is optimal. You can implement your own sorting algorithm (it's fairly easy) if you are unwilling to use the Arrays.sort() one.
Another related thread that asks similar question with an additional restriction: Removing the duplicates from an array without disturbing the order of elements without using Sets
Got a very Good Solution for this question : and it works perfectly . For those who are still searching answer for this question , you can use this below piece of code.
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class DuplicatesRemove {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Enter the array size :");
int size = Integer.parseInt(br.readLine());
int[] arr = new int[size];
// Creating the array
for (int i = 0; i < size; i++) {
System.out.print("Enter the element arr[" + i + "] = ");
arr[i] = Integer.parseInt(br.readLine());
System.out.println();
}
// displaying the array - it may contain elements in unsorted manner
System.out.println("Before Sorting :");
for (int i = 0; i < size; i++) {
System.out.println("Element arr[" + i + "] = " + arr[i]);
}
System.out
.println("*****************************************************");
// Logic for sorting the elements in the array
for (int i = 0; i < size; i++) {
for (int j = 1; j < size - i; j++) {
if (arr[j - 1] > arr[j]) {
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
// Printing the sorted elements - it may contain duplicate elements
System.out.println("After Sorting :");
for (int i = 0; i < size; i++) {
System.out.println("Element arr[" + i + "] = " + arr[i]);
}
System.out
.println("*****************************************************");
// Logic for removing the duplicate elements
int compare = 0;
arr[compare] = arr[0];
for (int i = 1; i < size; i++) {
if (arr[compare] != arr[i]) {
compare++;
arr[compare] = arr[i];
}
}
System.out.println("Array After removing duplicate elements is :");
for (int i = 0; i <= compare; i++) {
System.out.println("Element arr[" + i + "] = " + arr[i]);
}
}
}
public class UniqueElementinAnArray
{
public static void main(String[] args)
{
int[] a = {10,10,10,10,10,100};
int[] output = new int[a.length];
int count = 0;
int num = 0;
//Iterate over an array
for(int i=0; i<a.length; i++)
{
num=a[i];
boolean flag = check(output,num);
if(flag==false)
{
output[count]=num;
++count;
}
}
//print the all the elements from an array except zero's (0)
for (int i : output)
{
if(i!=0 )
System.out.print(i+" ");
}
}
/***
* If a next number from an array is already exists in unique array then return true else false
* @param arr Unique number array. Initially this array is an empty.
* @param num Number to be search in unique array. Whether it is duplicate or unique.
* @return true: If a number is already exists in an array else false
*/
public static boolean check(int[] arr, int num)
{
boolean flag = false;
for(int i=0;i<arr.length; i++)
{
if(arr[i]==num)
{
flag = true;
break;
}
}
return flag;
}
}
public int[] removeDuplicates(int[] arr) {
int[] res = new int[arr.length];
int index = 0;
for (int num : arr) {
if (res.indexOf(num) == -1)
res[index++] = num;
}
return res;
}
This is a suboptimal solution, however it does not require any sorting of the array. I create a new array, iterate through the items in the original one and add the items to the new array if they aren't already there.
public static int[] removeDuplicates(int[] input){
int j = 0;
int i = 1;
//return if the array length is less than 2
if(input.length < 2){
return input;
}
while(i < input.length){
if(input[i] == input[j]){
i++;
}else{
input[++j] = input[i++];
}
}
int[] output = new int[j+1];
for(int k=0; k<output.length; k++){
output[k] = input[k];
}
return output;
}
Source : http://java2novice.com/java-interview-programs/remove-duplicates-sorted-array/
int flag = 0, k = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arrAns.length; j++) {
if (arr[i] == arrAns[j]) {
flag = 0;
break;
}
flag=1;
}
if (flag == 1) {
arrAns[k] = arr[i];
k++;
}
flag = 0;
}
package practice1;
import java.util.Scanner;
public class RemoveArrayDuplicatesElements {
public static void main(String[] args) {
int i, j, k, size,same = 0;
System.out.println("\nEnter array size : ");
@SuppressWarnings("resource")
Scanner sc = new Scanner(System.in);
size = sc.nextInt();
int[] arr = new int[size+1];
System.out.println("\nAccept Numbers : ");
for (i = 0; i < size; i++)
arr[i] = sc.nextInt();
System.out.println("\nArray with Unique list : ");
for (i = 0; i < size; i++) {
for (j = i + 1; j < size;) {
if (arr[j] == arr[i]) {
same++;
for (k = j; k < size; k++) {
arr[k] = arr[k + 1];
}
size--;
} else
j++;
}
}
for (int g = 0; g < arr.length; g++) {
System.out.println(arr[g]);
}
}
}
Use below method:
/*
* Method to remove duplicates from array in Java, without using
* Collection classes e.g. Set or ArrayList. Algorithm for this
* method is simple, it first sort the array and then compare adjacent
* objects, leaving out duplicates, which is already in the result.
*/
public static int[] removeDuplicates(int[] numbersWithDuplicates) {
// Sorting array to bring duplicates together
Arrays.sort(numbersWithDuplicates);
int[] result = new int[numbersWithDuplicates.length];
int previous = numbersWithDuplicates[0];
result[0] = previous;
for (int i = 1; i < numbersWithDuplicates.length; i++) {
int ch = numbersWithDuplicates[i];
if (previous != ch) {
result[i] = ch;
}
previous = ch;
}
return result;
}
package com.array;
import java.util.*;
class RemoveDuplicatesInArray{
public static void main(String[] args) {
Integer[] array = new Integer[10];
array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 3;
array[4] = 3;
array[5] = 3;
array[6] = 7;
array[7] = 7;
array[8] = 9;
array[9] = 9;
removeDuplicatesFromArray(array);
}
private static void removeDuplicatesFromArray(Integer[] array){
StringBuffer stringBuffer = new StringBuffer();
String arrayString = Arrays.toString(array);
for(int index =0 ; index <= arrayString.length(); index++){
try{
int number = Integer.parseInt(arrayString.charAt(index)+"");
if(!stringBuffer.toString().contains(number+"")){
if(stringBuffer.length()!=0)
stringBuffer.append(",");
stringBuffer.append(number);
}
}catch(Exception e){
}
}
String[] stringArray = stringBuffer.toString().split(",");
array = new Integer[stringArray.length];
for(int index = 0 ; index < stringArray.length ; index++){
array[index] = Integer.parseInt(stringArray[index]);
}
System.out.println(Arrays.toString(array));
}
}
