Schnellste Weg, um zu überprüfen, ob alle Elemente in einem array gleich sind

Was wäre der Schnellste Weg, vorzugsweise native java zu überprüfen, ob alle Elemente eines Arrays sind die gleich einem Wert sind? (bezeichnet hier durch n)

Bisher habe ich:

boolean check = true;
int len = times.length;
for(int a = 0; check && a < len; a++) {
    check = times[a]==n && check;
}

Also, wenn jedes element ist gleich einem Wert, der check ist auf true gesetzt, ansonsten auf false gesetzt ist.

EDIT: Wäre das schneller?

boolean check = true;
int len = times.length
int a = 0;
while(a < len && times[a]==n) {
    a++;
}
check=(a==len);

Ok, nach einem Blick auf die Antworten hier verstehe ich den code so klein wie seine gonna bekommen, also werde ich schauen müssen, in threads und parallel processing, danke an alle für die Hilfe und die links

InformationsquelleAutor spyr03 | 2014-11-05

4

Dieser Algorithmus ist O(n) das ist der Schnellste Weg zu prüfen, alle Elemente einer Liste, weil Sie nur zu prüfen jedes element nur einmal.

Nun, nur weil das ist die Schnellste algorithm zu finden, wenn alle Elemente gleich einem Wert bedeutet nicht, dass Sie bereits optimiert haben, es zu seinem vollen potential.

Dieser dann lässt Platz für eine multi-threaded/multiprocessor Umsetzung.

Einer Lösung mit mehr Kernen oder threads aufteilen des Arrays in die Menge der Threads/Kerne, die Sie wollen, gleichzeitig zu Bearbeiten, d.h. wenn Sie ein array von 100 Elementen und wollen 10 threads gleichzeitig ausführen-- split das array in 10 Stücke und führen Sie jeden Abschnitt auf der Reihe.

Einige psudo-code:
```
 int from,to, threadCount = 10;
 boolean check[threadCount];  

 int factor = array.length()/threadCount;
 for(int i = 0; i < threadCount; i++){
      from = i*factor;
      to = i*factor+factor;
      newThreadProcess(from, to, array, check[i]);     
 }

 barrier(); //Wait till all the threads are done processing
 for(int i = 0; i < threadCount; i++){
    if(!check[i]) return false;
 }
 return true;
```
Dies ist am besten, wenn das array sehr groß
- Sententiously? Wie hat "gleichzeitig" erhalten, wandte sich in das?
InformationsquelleAutor Jay
15

In Java 8 haben, könnten Sie den Stream-API:
```
boolean check = Arrays.asList(times).stream().allMatch(t -> t == n);
```
Das allein wird nicht schneller sein als die Iteration über das array direkt. Aber wenn du dann wechseln Sie zu einer parallel stream, es könnte deutlich schneller auf große arrays. Und wenn die Leistung ein Problem darstellt, ist es vermutlich große arrays, die Sie interessieren.
```
boolean check = Arrays.asList(times).parallelStream().allMatch(t -> t == n);
```
Einen parallelen stream erlaubt die array-Scans werden parcelled aus mehreren threads, Scannen der Arrays mit parallel-CPUs oder Kerne.
- docs.oracle.com/javase/8/docs/api/java/util/stream/... sagt auch, dass allMatch() kann ein Kurzschluss auftreten, was bedeutet, es wird nicht Veranstaltung bewerten aller Elemente, wenn es feststellt, dass eine nicht-matching ein.
InformationsquelleAutor John Kugelman supports Monica
2
```
check = times[a]==n && check;
```
werden kann
```
check = times[a]==n;
```
da Sie würde nie bekommen haben, die Zeile, es sei denn check wahr.
- ok, das macht Sinn und gibt mir eine Idee für eine while-Schleife
InformationsquelleAutor Louis Wasserman

Eine einfache und saubere Art und Weise:

public static boolean allEqual(E[] array, E element) {
    for(E e : array) {
        if(e != element) {
            return false;
        }
    }
    return true;
}

InformationsquelleAutor Jean Logeart

1

Schreiben Sie es in einem kürzeren Weg :
```
for(int a = 0; a < len && (check = times[a]==n); a++);
```
- Sie würde umkehren die beiden Seiten der Bedingung also ein < len würde an den start gehen
- Guter Punkt, vielen Dank
InformationsquelleAutor ToYonos

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.