# Array auf doppelte Elemente überprüfen



## kilopack15 (9. Nov 2016)

Hallo Leute!
ich soll innerhalb eines Arrays prüfen, ob Elemente doppelt vorkommen. Wenn ja soll die Methode true zurückgeben. Wenn nein, ... ihr könnt es euch vorstellen 
Hier meine Lösung: Wäre schön wenn ihr mal drüberschaut und korrigiert, wenn ich was falsch gemacht habe:


```
// Wenn array mind . eine Zahl doppelt enthalt -> true ; andernfalls false .
        public static boolean hasDoppelte( int [] array ){
            for(int counter = 0;counter < (array.length);counter++){
                laufindex = array[counter];
                for(int counter2 = 0;counter2 < (array.length);counter2++){
                    if(array[counter] == array[counter2] && counter != counter2){
                        counter2 = array.length;
                        counter = array.length;
                        return true;
                    }
                }
                }
            return false;
        }
```


----------



## InfectedBytes (9. Nov 2016)

Die Klammern um _array.length_ sind nicht nötig.
Die Variable _laufindex_ kommt aus dem nichts und wird überhaupt nicht benutzt.
Es reicht wenn die innere Schleife bei counter+1 anfängt, dadurch musst du dann auch nicht mehr counter!=counter2 prüfen.
Die äußere Schleife muss nur bis array.length-1 laufen.
Die zuweisungen counter2=array.length und counter=array.length sind vollkommen unnötig.


----------



## stg (9. Nov 2016)

Alternativ auch erstmal sortieren (bzw eine sortierte Kopie deines Arrays anlegen, wenn du das ursprüngliche nicht verändern darfst). Dann musst du anschließend nur noch benachbarte Elemente prüfen.


----------



## kilopack15 (9. Nov 2016)

Im Nachhinein ist mir auch aufgefallen, dass da ziemlich viel unnötig war   Habs jetzt gekürzt. So müsste es ja richtig sein 

```
public static boolean hasDoppelte( int [] array ){
            for(int counter = 0;counter < array.length-1;counter++){
                for(int counter2 = (counter + 1);counter2 < array.length;counter2++){
                    if(array[counter] == array[counter2]){
                        return true;
                    }
                }
                }
            return false;
        }
}
```


----------



## Xyz1 (9. Nov 2016)

Das ist so i. O. - ist aber doch etwas umständlich.


----------



## JStein52 (9. Nov 2016)

DerWissende hat gesagt.:


> ist aber doch etwas umständlich.


warum ?


----------



## neoexpert (9. Nov 2016)

```
public static boolean hasDoppelte( Object [] a ){
        HashSet<Object> m=new HashSet<Object>();
        for(Object o:a)
            m.add(o);
          
        return m.size()!=a.length;
    }
```


----------



## Xyz1 (9. Nov 2016)

Eine der besten Lösungen wollte ich gar nicht sehen (auch da lässt sich noch ewas sparen)... Vielmehr ging es darum, z. B. erst mal sortieren.


----------



## neoexpert (9. Nov 2016)

DerWissende hat gesagt.:


> Eine der besten Lösungen wollte ich gar nicht sehen (auch da lässt sich noch ewas sparen)... Vielmehr ging es darum, z. B. erst mal sortieren.


Was genau kann man sparen?
Vllt:

```
return new HashSet<Object>(Arrays.asList(a)).size()!=a.length;
```


----------



## JStein52 (9. Nov 2016)

Leute, Leute, egal was ihr euch da noch so ausdenkt, die Lösung von @kilopack15 ist doch im Vergleich zu euren Verrenkungen auch nicht umständlicher.


----------



## neoexpert (9. Nov 2016)

JStein52 hat gesagt.:


> Leute, Leute, egal was ihr euch da noch so ausdenkt, die Lösung von @kilopack15 ist doch im Vergleich zu euren Verrenkungen auch nicht umständlicher.


Ist in O(n^2) meine ist in O(n)


----------



## mrBrown (9. Nov 2016)

neoexpert hat gesagt.:


> Ist in O(n^2) meine ist in O(n)


Seine erfüllt den Zweck der Aufgabe, deine nicht.


----------



## Nuiton (9. Nov 2016)

Theoretisch koennte man sich das Problem auch noch mit Java 8 Streams erleichtern - auch O(n).


----------



## mrBrown (9. Nov 2016)

Nuiton hat gesagt.:


> Theoretisch koennte man sich das Problem auch noch mit Java 8 Streams erleichtern - auch O(n).



Das wäre die vermutlich schönste Lösung 
Funktioniert aber intern auch über'ne HashMap


----------



## kilopack15 (10. Nov 2016)

Vielen Dank für eure Beiträge! 

```
HashSet<Object> m=new HashSet<Object>();
        for(Object o:a)
            m.add(o)
```
Hierbei weiß ich noch nicht was "HashSet" usw. ist. Das werde ich sicher noch lernen, aber mir ging es auch nicht darum den Code auf möglichst wenige Zeichen zu brechen, sondern einfach eine Methode zu entwickeln, die funktioniert 
Vielen Dank leute!


----------



## Xyz1 (11. Nov 2016)

Nicht asymptotisch betrachtet, kommst du auf n/2, wenn du bei einem doppelten Elem. sofort returnst... Aber darum gings mir gar nicht. HashMap ist hier wirklich fehl am Platze.


----------



## mrBrown (11. Nov 2016)

worum ging es dir denn?


----------

