it-swarm.asia

كيفية إزالة التكرارات بكفاءة من صفيف دون استخدام Set

لقد طُلب مني كتابة تنفيذي لإزالة القيم المكررة في صفيف. هنا هو ما خلقته. لكن بعد الاختبارات التي شملت 1،000،000 عنصر ، استغرق الأمر وقتًا طويلاً للغاية حتى انتهى. هل هناك شيء يمكنني القيام به لتحسين الخوارزمية الخاصة بي أو أي أخطاء لإزالتها؟

أحتاج إلى كتابة التنفيذ الخاص بي - وليس إلى استخدم Set ، HashSet إلخ أو أي أدوات أخرى مثل التكرارات. ببساطة صفيف لإزالة التكرارات.

public static int[] removeDuplicates(int[] arr) {

    int end = arr.length;

    for (int i = 0; i < end; i++) {
        for (int j = i + 1; j < end; j++) {
            if (arr[i] == arr[j]) {                  
                int shiftLeft = j;
                for (int k = j+1; k < end; k++, shiftLeft++) {
                    arr[shiftLeft] = arr[k];
                }
                end--;
                j--;
            }
        }
    }

    int[] whitelist = new int[end];
    for(int i = 0; i < end; i++){
        whitelist[i] = arr[i];
    }
    return whitelist;
}
38
ashur

نظرًا لأن هذا السؤال لا يزال يحظى كثيرًا من الاهتمام ، فقد قررت الإجابة عليه عن طريق نسخ هذه الإجابة من Code Review.SE :

أنت تتبع نفس الفلسفة التي تتبعها الفقاعة الفقاعية ، وهي بطيئة جدًا جدًا. هل جربت هذا؟:

  • فرز مجموعة غير مرتبة مع فرز سريع . فرز سريع هو أسرع بكثير من فرز الفقاعات (أعلم أنك لا تقوم بالفرز ، لكن الخوارزمية التي تتبعها هي نفسها تقريبًا مثل فرز الفقاعات لتجاوز الصفيف).

  • ثم ابدأ في إزالة التكرارات (ستكون القيم المتكررة بجوار بعضها البعض). في حلقة for ، يمكن أن يكون لديك مؤشران: source و destination. (في كل حلقة تقوم بنسخ source إلى destination ما لم تكن متماثلة ، وتزيد كل منهما بمقدار 1). في كل مرة تجد مصدرًا مكررًا لك (ولا تقوم بنسخ النسخة). morgano

2
ashur

يمكنك أن تأخذ مساعدة مجموعة جمع

int end = arr.length;
Set<Integer> set = new HashSet<Integer>();

for(int i = 0; i < end; i++){
  set.add(arr[i]);
}

الآن إذا كنت ستكرر من خلال هذا مجموعة ، وسوف تحتوي على قيم فريدة فقط. يشبه رمز التكرار:

Iterator it = set.iterator();
while(it.hasNext()) {
  System.out.println(it.next());
}
35
Android Killer

ملاحظة: أفترض أن المجموعة مصنفة.

الشفرة:

int[] input = new int[]{1, 1, 3, 7, 7, 8, 9, 9, 9, 10};
int current = input[0];
boolean found = false;

for (int i = 0; i < input.length; i++) {
    if (current == input[i] && !found) {
        found = true;
    } else if (current != input[i]) {
        System.out.print(" " + current);
        current = input[i];
        found = false;
    }
}
System.out.print(" " + current);

انتاج:

  1 3 7 8 9 10
15
Kick Buttowski

تعديل طفيف للرمز الأصلي نفسه ، عن طريق إزالة الأعمق للحلقة.

public static int[] removeDuplicates(int[] arr){
    int end = arr.length;

    for (int i = 0; i < end; i++) {
        for (int j = i + 1; j < end; j++) {
            if (arr[i] == arr[j]) {                  
                /*int shiftLeft = j;
                for (int k = j+1; k < end; k++, shiftLeft++) {
                    arr[shiftLeft] = arr[k];
                }*/
                arr[j] = arr[end-1];
                end--;
                j--;
            }
        }
    }

    int[] whitelist = new int[end];
    /*for(int i = 0; i < end; i++){
        whitelist[i] = arr[i];
    }*/
    System.arraycopy(arr, 0, whitelist, 0, end);
    return whitelist;
}
7
Pavan Kumar

نظرًا لأنه يمكنك افتراض أن النطاق يتراوح بين 0-1000 ، يوجد حل بسيط للغاية وفعال

//Throws an exception if values are not in the range of 0-1000
public static int[] removeDuplicates(int[] arr) {
    boolean[] set = new boolean[1001]; //values must default to false
    int totalItems = 0;

    for (int i = 0; i < arr.length; ++i) {
        if (!set[arr[i]]) {
            set[arr[i]] = true;
            totalItems++;
        }
    }

    int[] ret = new int[totalItems];
    int c = 0;
    for (int i = 0; i < set.length; ++i) {
        if (set[i]) {
            ret[c++] = i;
        }
    }
    return ret;
}

هذا يعمل في الوقت الخطي O (ن). تحذير: يتم فرز المصفوفة التي تم إرجاعها ، فإذا كان هذا غير قانوني ، فإن هذه الإجابة غير صالحة.

7
Esailija
class Demo 
{
    public static void main(String[] args) 
    {
        int a[]={3,2,1,4,2,1};
        System.out.print("Before Sorting:");
        for (int i=0;i<a.length; i++ )
        {
            System.out.print(a[i]+"\t");
        }
        System.out.print ("\nAfter Sorting:");
        //sorting the elements
        for(int i=0;i<a.length;i++)
        {
            for(int j=i;j<a.length;j++)
            {
                if(a[i]>a[j])
                {
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }

            }
        }

        //After sorting
        for(int i=0;i<a.length;i++)
        {
            System.out.print(a[i]+"\t");
        }
        System.out.print("\nAfter removing duplicates:");
        int b=0;
        a[b]=a[0];
        for(int i=0;i<a.length;i++)
        {
            if (a[b]!=a[i])
            {
                b++;
                a[b]=a[i];
            }
        }
        for (int i=0;i<=b;i++ )
        {
            System.out.print(a[i]+"\t");
        }
    }
}
  OUTPUT:Before Sortng:3 2 1 4 2 1 After Sorting:1 1 2 2 3 4 
                Removing Duplicates:1 2 3 4
6
user3752541

يوجد العديد من الحلول لهذه المشكلة.

  1. طريقة الفرز

    • يمكنك فرز الصفيف الخاص بك وحل العناصر الفريدة فقط
  2. النهج المحدد

    • تعلن HashSet حيث وضعت كل عنصر ثم لديك فقط فريدة من نوعها.
  3. يمكنك إنشاء صفيف منطقي يمثل العناصر التي تم إرجاعها جاهزة بالكامل ، (يعتمد هذا على بياناتك في الصفيف).

إذا كنت تتعامل مع كمية كبيرة من البيانات سأختار الحل 1.. نظرًا لعدم تخصيص ذاكرة إضافية والفرز سريع جدًا. بالنسبة لمجموعة صغيرة من البيانات ، سيكون التعقيد هو n ^ 2 ولكن بالنسبة إلى كبير ، سأكون n log n.

5
Damian Leszczyński - Vash

ماذا لو قمت بإنشاء صفيفين منطقيين: 1 للقيم السالبة والأخرى للقيم الموجبة والبدء في كل شيء على خطأ.

بعد ذلك تقوم بدورة صفيف مجموعة الإدخال والبحث في الصفائف إذا قمت بتثبيط القيمة بالفعل. إذا لم يكن كذلك ، فأنت تقوم بإضافته إلى صفيف الإخراج ووضع علامة عليه كما هو مستخدم بالفعل.

4
DaMachk

هذه طريقة بسيطة لفرز العناصر في الصفيف

public class DublicatesRemove {
    public static void main(String args[]) throws Exception {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("enter size of the array");
        int l = Integer.parseInt(br.readLine());
        int[] a = new int[l];
        // insert elements in the array logic
        for (int i = 0; i < l; i++) 
        {
            System.out.println("enter a element");
            int el = Integer.parseInt(br.readLine());
            a[i] = el;
        }
        // sorting elements in the array logic
        for (int i = 0; i < l; i++) 
        {
            for (int j = 0; j < l - 1; j++) 
            {
                if (a[j] > a[j + 1])
                {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        // remove duplicate elements logic
        int b = 0;
        a[b] = a[0];
        for (int i = 1; i < l; i++)
        {
            if (a[b] != a[i])
            {
                b++;
                a[b]=a[i];

            }

        }
        for(int i=0;i<=b;i++)
        {
            System.out.println(a[i]);
        }


    }
}
2
Tummala srikanth
package com.pari.practice;

import Java.util.HashSet;
import Java.util.Iterator;

import com.pari.sort.Sort;

public class RemoveDuplicates {

 /**
 * brute force- o(N square)
 * 
 * @param input
 * @return
 */
public static int[] removeDups(int[] input){
    boolean[] isSame = new boolean[input.length];
    int sameNums = 0;

    for( int i = 0; i < input.length; i++ ){
        for( int j = i+1; j < input.length; j++){
            if( input[j] == input[i] ){ //compare same
                isSame[j] = true;
                sameNums++;
            }
        }
    }

    //compact the array into the result.
    int[] result = new int[input.length-sameNums];
    int count = 0;
    for( int i = 0; i < input.length; i++ ){
        if( isSame[i] == true) {
            continue;
        }
        else{
            result[count] = input[i];
            count++;
        }
    }

    return result;
}

/**
 * set - o(N)
 * does not guarantee order of elements returned - set property
 * 
 * @param input
 * @return
 */
public static int[] removeDups1(int[] input){
    HashSet myset = new HashSet();

    for( int i = 0; i < input.length; i++ ){
        myset.add(input[i]);
    }

    //compact the array into the result.
    int[] result = new int[myset.size()];
    Iterator setitr = myset.iterator();
    int count = 0;
    while( setitr.hasNext() ){
        result[count] = (int) setitr.next();
        count++;
    }

return result;
}

/**
 * quicksort - o(Nlogn)
 * 
 * @param input
 * @return
 */
public static int[] removeDups2(int[] input){
    Sort st = new Sort();
    st.quickSort(input, 0, input.length-1); //input is sorted

    //compact the array into the result.
    int[] intermediateResult = new int[input.length];
    int count = 0;
    int prev = Integer.MIN_VALUE;
    for( int i = 0; i < input.length; i++ ){
        if( input[i] != prev ){
            intermediateResult[count] = input[i];
            count++;
        }
        prev = input[i];
    }

    int[] result = new int[count];
    System.arraycopy(intermediateResult, 0, result, 0, count);

    return result;
}


public static void printArray(int[] input){
    for( int i = 0; i < input.length; i++ ){
        System.out.print(input[i] + " ");
    }
}

public static void main(String[] args){
    int[] input = {5,6,8,0,1,2,5,9,11,0};
    RemoveDuplicates.printArray(RemoveDuplicates.removeDups(input));
    System.out.println();
    RemoveDuplicates.printArray(RemoveDuplicates.removeDups1(input));
    System.out.println();
    RemoveDuplicates.printArray(RemoveDuplicates.removeDups2(input));
}
}

الناتج: 5 6 8 - 1 2 9 11

0 1 2 5 6 8 9 11

0 1 2 5 6 8 9 11

لقد كتبت للتو الرمز أعلاه لمحاولة الخروج. شكر.

2
user3222017
public static int[] removeDuplicates(int[] arr){
    HashSet<Integer> set = new HashSet<>();
    final int len = arr.length;
    //changed end to len
    for(int i = 0; i < len; i++){
        set.add(arr[i]);
    }

    int[] whitelist = new int[set.size()];
    int i = 0;
    for (Iterator<Integer> it = set.iterator(); it.hasNext();) {
        whitelist[i++] = it.next();
    }
    return whitelist;
}

يعمل في O(N) وقت بدلاً من O (N ^ 3) وقتك

2
David Xu
int tempvar=0; //Variable for the final array without any duplicates
     int whilecount=0;    //variable for while loop
     while(whilecount<(nsprtable*2)-1) //nsprtable can be any number
     {
//to check whether the next value is idential in case of sorted array       
if(temparray[whilecount]!=temparray[whilecount+1])
        {
            finalarray[tempvar]=temparray[whilecount];
            tempvar++;
            whilecount=whilecount+1;
        }
        else if (temparray[whilecount]==temparray[whilecount+1])
        {
            finalarray[tempvar]=temparray[whilecount];
            tempvar++;
            whilecount=whilecount+2;
        }
     }

نأمل أن يكون هذا يساعد أو يحل الغرض.

1
driftking9987
public static void main(String args[]) {
    int[] intarray = {1,2,3,4,5,1,2,3,4,5,1,2,3,4,5};

    Set<Integer> set = new HashSet<Integer>();
    for(int i : intarray) {
        set.add(i);
    }

    Iterator<Integer> setitr = set.iterator();
    for(int pos=0; pos < intarray.length; pos ++) {
        if(pos < set.size()) {
            intarray[pos] =setitr.next();
        } else {
            intarray[pos]= 0;
        }
    }

    for(int i: intarray)
    System.out.println(i);
}
1
Programmer

تحتاج إلى فرز الصفيف الخاص بك ثم حلقة وإزالة التكرارات. كما لا يمكنك استخدام أدوات أخرى تحتاج إلى كتابة رمز نفسك.

يمكنك بسهولة العثور على أمثلة من فرز سريع في Java على الإنترنت (يعتمد هذا المثال).

public static void main(String[] args) throws Exception {
    final int[] original = new int[]{1, 1, 2, 8, 9, 8, 4, 7, 4, 9, 1};
    System.out.println(Arrays.toString(original));
    quicksort(original);
    System.out.println(Arrays.toString(original));
    final int[] unqiue = new int[original.length];
    int prev = original[0];
    unqiue[0] = prev;
    int count = 1;
    for (int i = 1; i < original.length; ++i) {
        if (original[i] != prev) {
            unqiue[count++] = original[i];
        }
        prev = original[i];
    }
    System.out.println(Arrays.toString(unqiue));
    final int[] compressed = new int[count];
    System.arraycopy(unqiue, 0, compressed, 0, count);
    System.out.println(Arrays.toString(compressed));
}

private static void quicksort(final int[] values) {
    if (values.length == 0) {
        return;
    }
    quicksort(values, 0, values.length - 1);
}

private static void quicksort(final int[] values, final int low, final int high) {
    int i = low, j = high;
    int pivot = values[low + (high - low) / 2];
    while (i <= j) {
        while (values[i] < pivot) {
            i++;
        }
        while (values[j] > pivot) {
            j--;
        }
        if (i <= j) {
            swap(values, i, j);
            i++;
            j--;
        }
    }
    if (low < j) {
        quicksort(values, low, j);
    }
    if (i < high) {
        quicksort(values, i, high);
    }
}

private static void swap(final int[] values, final int i, final int j) {
    final int temp = values[i];
    values[i] = values[j];
    values[j] = temp;
}

وبالتالي فإن العملية تعمل في 3 خطوات.

  1. فرز الصفيف - O(nlgn)
  2. إزالة التكرارات - O(n)
  3. ضغط الصفيف - O(n)

لذلك هذا يحسن بشكل ملحوظ على طريقة O(n^3) الخاصة بك.

انتاج:

[1, 1, 2, 8, 9, 8, 4, 7, 4, 9, 1]
[1, 1, 1, 2, 4, 4, 7, 8, 8, 9, 9]
[1, 2, 4, 7, 8, 9, 0, 0, 0, 0, 0]
[1, 2, 4, 7, 8, 9]

[~ # ~] تحرير [~ # ~]

الدول OP القيم داخل مجموعة لا يهم حقا. ولكن يمكنني أن أفترض أن هذا النطاق يتراوح بين 0-1000. هذه حالة كلاسيكية حيث يمكن استخدام نوع O(n)).

نخلق مجموعة من الحجم range +1 ، في هذه الحالة 1001. نحن ثم حلقة فوق البيانات وزيادة القيم على كل مؤشر المقابلة ل datapoint.

يمكننا بعد ذلك ضغط الصفيف الناتج ، وإسقاط القيم التي لم يتم زيادتها. هذا يجعل القيم فريدة ونحن نتجاهل العد.

public static void main(String[] args) throws Exception {
    final int[] original = new int[]{1, 1, 2, 8, 9, 8, 4, 7, 4, 9, 1, 1000, 1000};
    System.out.println(Arrays.toString(original));
    final int[] buckets = new int[1001];
    for (final int i : original) {
        buckets[i]++;
    }
    final int[] unique = new int[original.length];
    int count = 0;
    for (int i = 0; i < buckets.length; ++i) {
        if (buckets[i] > 0) {
            unique[count++] = i;
        }
    }
    final int[] compressed = new int[count];
    System.arraycopy(unique, 0, compressed, 0, count);
    System.out.println(Arrays.toString(compressed));
}

انتاج:

[1, 1, 2, 8, 9, 8, 4, 7, 4, 9, 1, 1000, 1000]
[1, 2, 4, 7, 8, 9, 1000]
1
Boris the Spider

لمصفوفة مصنفة ، فقط تحقق من الفهرس التالي:

//sorted data!
public static int[] distinct(int[] arr) {
    int[] temp = new int[arr.length];

    int count = 0;
    for (int i = 0; i < arr.length; i++) {
        int current = arr[i];

        if(count > 0 )
            if(temp[count - 1] == current)
                continue;

        temp[count] = current;
        count++;
    }

    int[] whitelist = new int[count];
    System.arraycopy(temp, 0, whitelist, 0, count);

    return whitelist;
}
1
mc_fish

ليس متعة كبيرة في تحديث إدخال المستخدم ، ولكن النظر في القيود الخاصة بك ...

public int[] removeDup(int[] nums) {
  Arrays.sort(nums);
  int x = 0;
  for (int i = 0; i < nums.length; i++) {
    if (i == 0 || nums[i] != nums[i - 1]) {
    nums[x++] = nums[i];
    }
  }
  return Arrays.copyOf(nums, x);
}

يمكن استبدال ترتيب الصفيف بسهولة بأي خوارزمية nlog (n).

1
Maurizio Cucchiara

أعلم أن هذا قد مات لكنني كتبت هذا للاستخدام الخاص بي. إنه يشبه إلى حد ما الإضافة إلى hashset ثم سحب كل العناصر منه. يجب تشغيله في O(nlogn) أسوأ الحالات.

    public static int[] removeDuplicates(int[] numbers) {
    Entry[] entries = new Entry[numbers.length];
    int size = 0;
    for (int i = 0 ; i < numbers.length ; i++) {
        int nextVal = numbers[i];
        int index = nextVal % entries.length;
        Entry e = entries[index];
        if (e == null) {
            entries[index] = new Entry(nextVal);
            size++;
        } else {
            if(e.insert(nextVal)) {
                size++;
            }
        }
    }
    int[] result = new int[size];
    int index = 0;
    for (int i = 0 ; i < entries.length ; i++) {
        Entry current = entries[i];
        while (current != null) {
            result[i++] = current.value;
            current = current.next;
        }
    }
    return result;
}

public static class Entry {
    int value;
    Entry next;

    Entry(int value) {
        this.value = value;
    }

    public boolean insert(int newVal) {
        Entry current = this;
        Entry prev = null;
        while (current != null) {
            if (current.value == newVal) {
                return false;
            } else if(current.next != null) {
                prev = current;
                current = next;
            }
        }
        prev.next = new Entry(value);
        return true;
    }
}
1
Eagle

إن الطريقة الأكثر فاعلية لإزالة التكرارات من صفيف صحيح دون استخدام مجموعة هي ، فقط قم بإنشاء مصفوفة مؤقت وتكرار المصفوفة الأصلية وتحقق مما إذا كان الرقم موجودًا في مصفوفة temp ثم لا تضغط في مصفوفة أخرى توضع في مصفوفة مؤقتة وتُرجع مصفوفة مؤقتة نتيجة لذلك . يرجى النظر في مقتطف الشفرة التالي:

package com.numbers;

import Java.util.Arrays;

public class RemoveDuplicates {
    public int[] removeDuplicate(int[] array) {
        int[] tempArray = new int[array.length];
        int j = 0;
        for (int i : array) {
            if (!isExists(tempArray, i)) {
                tempArray[j++] = i;
            }
        }
        return tempArray;
    }

    public static boolean isExists(int[] array, int num) {
        if (array == null)
            return false;
        for (int i : array) {
            if (i == num) {
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        int [] array = { 10, 20, 30, 10, 45, 30 };
        RemoveDuplicates duplicates = new RemoveDuplicates();
        System.out.println("Before removing duplicates : " + Arrays.toString(array));
        int [] newArray = duplicates.removeDuplicate(array);
        System.out.println("After removing duplicates : " + Arrays.toString(newArray));

    }
}
0
Sudhir Ojha

ماذا عن هذا ، فقط للصفيف المفروزة من الأرقام ، لطباعة صفيف بدون تكرارات ، بدون استخدام Set أو مجموعات أخرى ، فقط Array:

 public static int[] removeDuplicates(int[] array) {
    int[] nums =new int[array.length];
    int addedNum = 0;
    int j=0;
    for(int i=0;i<array.length;i++) {
        if (addedNum != array[i]) {
        nums[j] = array[i];
        j++;
        addedNum = nums[j-1];
        }
    }
    return Arrays.copyOf(nums, j);
}

مجموعة من 1040 رقمًا مكررًا تم معالجتها في 33020 نانوثانية (.033020 ميلي ثانية).

0
pandabear
 package javaa;

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;
}

}

0
Avinash Pande

مجرد خدعة لإزالة التكرارات.

public class RemoveDuplicates {
    public static void main(String[] args) {
        int[] arr = {2,2,2,2,2,5,9, 4,5,6,1,6,6,2,4,7};
        arr = removeDuplicates(arr);    
        print(arr);
    }

    public static int[] removeDuplicates(int [] arr) {
        final int garbage = -2147483648;
        int duplicates = 0;

        for(int i=0; i<arr.length; i++) {
            for(int j=i+1; j<arr.length; j++) {
                if (arr[i] == arr[j]) {
                    arr[i] = garbage;
                    duplicates++;
                }
            }
        }

        int[] nArr = new int[arr.length - duplicates];
        int nItr = 0;
        for(int i=0; i<arr.length; i++) {
            if (arr[i] != garbage) {
                nArr[nItr] = arr[i];
                nItr++;
            } 
        }
        return nArr;
    }

    public static void print(int [] arr) {
        for (int n : arr) {
            System.out.print(n + "\t");
        }
    }

}
0
Abdul Rehman Mehar

لماذا لا يقوم جميع الأشخاص بالتحقق من هذه الأسطر أدناه؟

أحتاج إلى كتابة التنفيذ الخاص بي - وليس لاستخدام Set أو HashSet وما إلى ذلك أو أي أدوات أخرى مثل التكرارات. ببساطة صفيف لإزالة التكرارات.

أنا نشر تطبيق بسيط للغاية مع رعاية السطر أعلاه.

public class RemoveDuplicates {

public static void main(String[] args) {

    int[] arr = { 1, 2, 3, 4, 2, 3, 1 }; // input array
    int len = arr.length;
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < len; j++) {
            if (arr[i] == arr[j]) {
                while (j < (len) - 1) {
                    arr[j] = arr[j - 1];
                    j++;
                }
                len--;
            }
        }
    }
    for (int i = 0; i < len; i++) {
        System.out.print("  " +arr[i]);
    }

   }
 }

المدخلات: 1 ، 2 ، 3 ، 4 ، 2 ، 3 ، 1

الإخراج: 1 2 3 4

0
Ved Prakash
public static void main(String[] args) {
        Integer[] intArray = { 1, 1, 1, 2, 4, 2, 3, 5, 3, 6, 7, 3, 4, 5 };
        Integer[] finalArray = removeDuplicates(intArray);
        System.err.println(Arrays.asList(finalArray));
    }

    private static Integer[] removeDuplicates(Integer[] intArray) {
        int count = 0;
        Integer[] interimArray = new Integer[intArray.length];
        for (int i = 0; i < intArray.length; i++) {
            boolean exists = false;
            for (int j = 0; j < interimArray.length; j++) {
                if (interimArray[j]!=null && interimArray[j] == intArray[i]) {
                    exists = true;
                }
            }
            if (!exists) {
                interimArray[count] = intArray[i];
                count++;
            }
        }
        final Integer[] finalArray = new Integer[count];
        System.arraycopy(interimArray, 0, finalArray, 0, count);
        return finalArray;
    }
0
venkata harish
public void removeDup(){ 
String[] arr = {"1","1","2","3","3"};
          boolean exists = false;
          String[] arr2 = new String[arr.length];
          int count1 = 0;
          for(int loop=0;loop<arr.length;loop++)
            {
              String val = arr[loop];
              exists = false;
              for(int loop2=0;loop2<arr2.length;loop2++)
              {     
                  if(arr2[loop2]==null)break;
                  if(arr2[loop2]==val){
                        exists = true;
                }
              }
              if(!exists) {
                    arr2[count1] = val;
                    count1++;
              }
            }
}
0
Pradeep
public static int[] removeDuplicates(int[] arr) {

int end = arr.length;

 HashSet<Integer> set = new HashSet<Integer>(end);
    for(int i = 0 ; i < end ; i++){
        set.add(arr[i]);
    }
return set.toArray();
}
0
Falguni

أشعر أن Android فكرة Killer رائعة ، لكنني فقط تساءلت عما إذا كان بإمكاننا الاستفادة من HashMap. لذلك قمت بتجربة صغيرة. لقد وجدت HashMap تبدو أسرع من HashSet.

هنا هو الكود:

    int[] input = new int[1000000];

    for (int i = 0; i < input.length; i++) {
        Random random = new Random();
        input[i] = random.nextInt(200000);
    }

    long startTime1 = new Date().getTime();
    System.out.println("Set start time:" + startTime1);

    Set<Integer> resultSet = new HashSet<Integer>();

    for (int i = 0; i < input.length; i++) {
        resultSet.add(input[i]);
    }

    long endTime1 = new Date().getTime();
    System.out.println("Set end time:"+ endTime1);
    System.out.println("result of set:" + (endTime1 - startTime1));     
    System.out.println("number of Set:" + resultSet.size() + "\n");

    long startTime2 = new Date().getTime();
    System.out.println("Map start time:" + startTime1);

    Map<Integer, Integer> resultMap = new HashMap<Integer, Integer>();

    for (int i = 0; i < input.length; i++) {
        if (!resultMap.containsKey(input[i]))
            resultMap.put(input[i], input[i]);
    }

    long endTime2 = new Date().getTime();
    System.out.println("Map end Time:" + endTime2);
    System.out.println("result of Map:" + (endTime2 - startTime2));
    System.out.println("number of Map:" + resultMap.size());

هنا النتيجة:

Set start time:1441960583837
Set end time:1441960583917
result of set:80
number of Set:198652

Map start time:1441960583837
Map end Time:1441960583983
result of Map:66
number of Map:198652
0
Jonathan

إليكم الحل. تعقيد الوقت هو o (n ^ 2)

public String removeDuplicates(char[] arr) {
        StringBuilder sb = new StringBuilder();

        if (arr == null)
            return null;
        int len = arr.length;

        if (arr.length < 2)
            return sb.append(arr[0]).toString();

        for (int i = 0; i < len; i++) {

            for (int j = i + 1; j < len; j++) {
                if (arr[i] == arr[j]) {
                    arr[j] = 0;

                }
            }
            if (arr[i] != 0)
                sb.append(arr[i]);
        }

        return sb.toString().trim();
    }
0
Türkmen Mustafa Demirci

إذا كان مسموحًا لك باستخدام Java 8 تدفقات:

Arrays.stream(arr).distinct().toArray();
0
Tomin

حسنًا ، لذلك لا يمكنك استخدام Set أو المجموعات الأخرى. أحد الحلول التي لا أراها هنا حتى الآن هو حل يستند إلى استخدام مرشح Bloom ، والذي يعد أساسًا مجموعة من البتات ، لذلك ربما يتجاوز متطلباتك.

يعد مرشح Bloom تقنية رائعة وسهلة الاستخدام ، تتميز بالسرعة والفعالية من حيث المساحة ، والتي يمكن استخدامها لإجراء فحص سريع لوجود عنصر في مجموعة دون تخزين المجموعة نفسها أو العناصر. لديه معدل إيجابي خاطئ (صغير) ، لكن لا يوجد معدل سلبي كاذب. بمعنى آخر ، بالنسبة لسؤالك ، إذا أخبرك عامل تصفية Bloom أنه لم يتم رؤية عنصر حتى الآن ، فيمكنك أن تتأكد من عدم ظهوره. ولكن إذا كان قد تم عرض عنصر ، فستحتاج إلى التحقق بالفعل. لا يزال هذا يوفر الكثير من الوقت إذا لم يكن هناك الكثير من التكرارات في قائمتك (بالنسبة لهؤلاء ، لا توجد حلقات للقيام بها ، باستثناء في حالة الاحتمال الصغيرة للإيجاب الخاطئ - عادة ما تختار هذا المعدل بناءً على مقدار المساحة التي ترغب في منحها لمرشح Bloom (قاعدة التجربة: أقل من 10 بت لكل عنصر فريد لمعدل إيجابي خاطئ قدره 1٪).

هناك العديد من تطبيقات عوامل تصفية Bloom ، راجع على سبيل المثال هنا أو هنا ، لذلك لن أكرر ذلك في هذه الإجابة. دعنا نفترض فقط api الموصوف في هذا المرجع الأخير ، على وجه الخصوص ، الوصف of put(E e):

true إذا تغيرت بتات مرشح Bloom كنتيجة لهذه العملية. إذا تغيرت البتات ، فهذا بالتأكيد تمت إضافة كائن المرة الأولى إلى المرشح. إذا لم تتغير البتات ، فقد يكون هذا أول مرة تتم فيها إضافة كائن إلى الفلتر. (...)

التنفيذ باستخدام مرشح Bloom سيكون:

public static int[] removeDuplicates(int[] arr) {
    ArrayList<Integer> out = new ArrayList<>();
    int n = arr.length;
    BloomFilter<Integer> bf = new BloomFilter<>(...);  // decide how many bits and how many hash functions to use (compromise between space and false positive rate)

    for (int e : arr) {
        boolean might_contain = !bf.put(e);
        boolean found = false;
        if (might_contain) {
            // check if false positive
            for (int u : out) {
                if (u == e) {
                    found = true;
                    break;
                }
            }
        }
        if (!found) {
            out.add(e);
        }
    }
    return out.stream().mapToInt(i -> i).toArray();
}

من الواضح ، إذا كان يمكنك تغيير الصفيف الوارد في مكانه ، فلا داعي لـ ArrayList: في النهاية ، عندما تعرف العدد الفعلي للعناصر الفريدة ، فقط arraycopy() تلك.

0
Pierre D

هذا لا يستخدم Set ، Map ، List أو أي مجموعة إضافية ، صفيفان فقط:

package arrays.duplicates;

import Java.lang.reflect.Array;
import Java.util.Arrays;

public class ArrayDuplicatesRemover<T> {

    public static <T> T[] removeDuplicates(T[] input, Class<T> clazz) {
        T[] output = (T[]) Array.newInstance(clazz, 0);
        for (T t : input) {
            if (!inArray(t, output)) {
                output = Arrays.copyOf(output, output.length + 1);
                output[output.length - 1] = t;
            }
        }
        return output;
    }

    private static <T> boolean inArray(T search, T[] array) {
        for (T element : array) {
            if (element.equals(search)) {
                return true;
            }
        }
        return false;
    }

}

والرئيسي لاختباره

package arrays.duplicates;

import Java.util.Arrays;

public class TestArrayDuplicates {

    public static void main(String[] args) {
        Integer[] array = {1, 1, 2, 2, 3, 3, 3, 3, 4};
        testArrayDuplicatesRemover(array);
    }

    private static void testArrayDuplicatesRemover(Integer[] array) {
        final Integer[] expectedResult = {1, 2, 3, 4};
        Integer[] arrayWithoutDuplicates = ArrayDuplicatesRemover.removeDuplicates(array, Integer.class);
        System.out.println("Array without duplicates is supposed to be: " + Arrays.toString(expectedResult));
        System.out.println("Array without duplicates currently is: " + Arrays.toString(arrayWithoutDuplicates));
        System.out.println("Is test passed ok?: " + (Arrays.equals(arrayWithoutDuplicates, expectedResult) ? "YES" : "NO"));
    }

}

والإخراج:

Array without duplicates is supposed to be: [1, 2, 3, 4]
Array without duplicates currently is: [1, 2, 3, 4]
Is test passed ok?: YES
0
Juan Furattini

إليك طريقة أكثر بساطة وأفضل للقيام بذلك باستخدام قوائم الصفيف بدلاً من ذلك:

public static final <T> ArrayList<T> removeDuplicates(ArrayList<T> in){
    ArrayList<T> out = new ArrayList<T>();
    for(T t : in) 
        if(!out.contains(t)) 
            out.add(t);
    return out;
}
0
Jeremiah

هذا سؤال المقابلة: أزل التكرارات من صفيف. لا يجوز لي استخدام أي مجموعة أو مجموعات. الحل الكامل هو:

public class Test4 {
public static void main(String[] args) {
     int a[] = {1, 2, 2, 3, 3, 3, 6,6,6,6,6,66,7,65}; 
              int newlength =    lengthofarraywithoutduplicates(a);
              for(int i = 0 ; i < newlength ;i++) {
                  System.out.println(a[i]);
              }//for
}//main

private static int lengthofarraywithoutduplicates(int[] a) {
     int count = 1 ;
     for (int i = 1; i < a.length; i++) {
          int ch = a[i];
          if(ch != a[i-1]) {
              a[count++] = ch;
          }//if
    }//for
    return count;

}//fix

}//end1
0
Soudipta Dutta