Wie, um Duplikate zu finden, die in einem java-array?

Ich versuche zu zählen, wie viele doppelte Elemente in einem array.

Beispiel:

[0, 2, 0] would return 2, [0, 0, 0] would return 3, [0, 1, 2] = 0

Bisher habe ich es funktioniert, wenn alle drei Elemente gleich sind, aber ich bin mir nicht sicher, warum es ist die Rückkehr eines weniger als das, was es sollte für 2 Produkte sind die gleichen.

    int equal = 0;

    for(int i = 0; i < recent.length; i++) {
        for(int j = i; j < recent.length; j++) {
            if(i != j && recent[i].equals(recent[j])) {
                equal++;
            }
        }
    }

Müssen Sie überdenken das problem.
Insbesondere sollten Sie überdenken Sie Ihre definition des Problems. Was genau versuchen Sie zu zählen - wie viele duplizierte Elemente es gibt, oder wie viele Paare von gleichen Elementen gibt es?
Investieren Sie etwas Zeit in das Lesen der Dokumentation für HashMap.
Was würde [0, 2, 0, 2, 0] zurück - nur eine einzige Zahl? Was würde es sein?

InformationsquelleAutor user1859040 | 2012-12-01

1

Algorithmus ist fehlerhaft in der folgenden Art und Weise: für jedes element im array, die Sie Blick auf all die Elemente, nachdem das element aus und wenn Sie zufällig gleich sein, erhöhen Sie den Zähler. Allerdings, wenn du 3 gleiche Elemente zählen Sie die letzten zweimal beim ausführen von internen Schleife zum ersten und zum zweiten element. Außerdem werden Sie nie zählen Sie das erste element.

Damit es funktioniert, durch Zufall für [0, 0, 0] funktioniert aber nicht für andere Eingänge.

InformationsquelleAutor Tomasz Nurkiewicz

Ich denke, dass mit verschachtelten Schleifen ist ziemlich ineffizient. Sie sollten in der Lage sein, es zu tun in o(n) anstatt o(n^2).

Wenn du mal deins gegen folgende...

public void run() {
    int[] array = createRandomArray(2000000, 1000000);
    System.out.println(countNumDups1(array));
}


private int[] createRandomArray(int numElements, int maxNumExclusive) {
    int[] array = new int[numElements];
    Random random = new Random();
    for (int i = 0; i < array.length; i++) {
        array[i] = random.nextInt(maxNumExclusive);
    }
    return array;
}

private int countNumDups1(int[] array) {
    Map<Integer, Integer> numToCountMap = new HashMap<>();
    for (int i = 0; i < array.length; i++) {
        Integer key = array[i];
        if (numToCountMap.containsKey(key)) {
            numToCountMap.put(key, numToCountMap.get(key) + 1);
        }
        else {
            numToCountMap.put(key, 1);
        }
    }
    int numDups = 0;
    for (int i = 0; i < array.length; i++) {
        Integer key = array[i];
        if (numToCountMap.get(key) > 1) {
            numDups++;
        }
    }
    return numDups;
}

Ich glaube, Sie finden die oben ist viel schneller, auch wenn man bedenkt das schreckliche Ineffizienz des autoboxing und-Objekt erstellen.

mfb ' s Lösung ist besser als meine. Beide sind in o(n) aber seinen Willen ausführen, ein paar mal schneller ich Stelle mir.
+1 pk, noch eine gute Lösung! 😀

InformationsquelleAutor kelceyp

Code, den Sie gab, zählt äquivalenzen, so fügt es ein jedes mal, wenn ein element ist gleich einem anderen element ist.

Es klingt wie das, was Sie wollen, ist die Anzahl von doppelten Elementen, das ist das gleiche wie (Länge, Anzahl der Elemente, die keine Duplikate). Ich nenne das letztere "uniqueItems".

Ich würde empfehlen, die folgenden:

//set of every item seen
Set<Integer> allItems = new HashSet<Integer>();
//set of items that don't have a duplicate
Set<Integer> uniqueItems = new HashSet<Integer>();

for(int i = 0; i < recent.length; i++) {
    Integer val = i;
    if(allItems.contains(val)) {
        //if we've seen the value before, it is not a "uniqueItem"
        uniqueItems.remove(val); 
    } else {
        //assume the value is a "uniqueItem" until we see it again
        uniqueItems.add(val);
    }
    allItems.add(val);
}
return recent.length - uniqueItems.size();

InformationsquelleAutor mbarrows

Den code unten funktioniert einwandfrei zu finden, die Duplikate

    int array[] = {1,2,3,4,5,2,3,4,5,3,4,5,4,5,5};

    HashMap<Integer,Integer> duplicates = new HashMap<Integer,Integer>();
    for(int i=0; i<array.length; i++)
    {
        if(duplicates.containsKey(array[i]))
        {
            int numberOfOccurances = duplicates.get(array[i]);
            duplicates.put(array[i], (numberOfOccurances + 1));
        }else{
            duplicates.put(array[i], 1);
        }
    }
    Iterator<Integer> keys = duplicates.keySet().iterator();
    System.out.print("Duplicates : " );
    while(keys.hasNext())
    {
        int k = keys.next(); 
        if(duplicates.get(k) > 1)
        {
            System.out.print(" "+k);
        }
    }

InformationsquelleAutor user2418284

0

Sind Sie zählen die Anzahl der Paare von Indizes, die die gleichen Werte. Was Sie behaupten zu wollen, ist die Gesamtgröße aller Gruppen gleicher Elemente, die mehr als ein element in Ihnen.

Ich würde eine Karte oder ähnliches zum zählen der Gesamtzahl der Erscheinungen von einem vorgegebenen Wert. Am Ende der Iteration über die Schlüssel-Werte hinzufügen, die Anzahl der Auftritte für jede Taste, die mehr als eine Erscheinung.

InformationsquelleAutor Patricia Shanahan

int intArray[] = {5, 1, 2, 3, 4, 5, 3, 2};  

String val = "";

int c = 1;

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

for (int i = 0; i < intArray.length; i++) {

    Integer key = intArray[i];

        if(nwmap.get(key) != null && nwmap.containsKey(key)){

        val += " Duplicate: " +String.valueOf(key)+"\n";

    }else{

        nwmap.put(key, c);

            c++;

    }

}

LOG.debug("duplicate value:::"+val);

InformationsquelleAutor Diana

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;


public class ArrayDuplicateCount {

    /**
     * @author:raviteja katari
     */
    public static void main(String[] args) {
        int intArray[] = {5, 1,4,4,4,5,1,2,1,2,5,5};  


        //for counting duplicate items
        int c = 0;

        //creating map collection to hold integers as keys and Cont as value
        Map<Integer, Integer> nwmap = new LinkedHashMap<Integer, Integer>();  

        for (int i = 0; i <intArray.length; i++) {

            //Assigning array element to key 
            Integer key = intArray[i];

                //this code checks for elemnt if present updates count value else 
                //put the new Array elemnt into map and increment count

                if(nwmap.containsKey(key)){

                    //updating key value by 1 
                    nwmap.put(key, nwmap.get(key) + 1);

            }else{

                //Adding new array element to map and increasing count by 1
                  nwmap.put(key, c+1);


                   }

                           }
          //printing map
        System.out.println(nwmap);
    }

}

Ausgabe:
{5=4, 1=3, 4=3, 2=2}

InformationsquelleAutor raviteja katari

0
```
    public void TotalduplicateNumbers {
    int a[] = {2,8,2,4,4,6,7,6,8,4,5};
    Map<Integer,Integer> m = new HashMap<Integer,Integer>();
    for(int i=0;i<a.length;i++){            

            if(!m.containsKey(a[i]))
            {
                m.put(a[i], 1);
            }
            else
            {
                m.put(a[i], (m.get(a[i])+1));
            }

    }

    for(Integer i:m.keySet()){
        System.out.println("Number "+i+" "+"Occours "+m.get(i)+" time,");
    }
}
```
Haben wir ein array mit 11 zahlen, Die Logik ist, eine map zu erstellen mit diesen nicht. in dem SCHLÜSSEL der map werden die tatsächliche Anzahl, die eingegeben werden müssen durch die Benutzer und keine. der occournce, dass tatsächliche keine. wäre der Wert dieses SCHLÜSSELS. Hier containsKey () - Methode prüft, ob die Karte enthalten, dass der Schlüssel bereits und Rückgabe boolescher Wert, der true oder false als angewendet.Wenn es nicht enthalten, dann fügen Sie die Schlüssel in die Karte und der entsprechende Wert sollte 1 sein, sonst key würde bereits enthalten sein, in anzeigen so rufen Sie den Wert des Schlüssel mit get() und erhöhen Sie um 1. Schließlich drucken die Karte.

AUSGABE:--

Nummer 2 Aufgetreten ist 2 mal
Nummer 4 Occours 3 mal
Nummer 5 Aufgetreten, 1 mal,
Nummer 6 Aufgetreten ist 2 mal
Nummer 7 Aufgetreten, 1 mal,
Nummer 8 Aufgetreten ist 2 mal

InformationsquelleAutor Khan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.