Finden Sie alle Zahlenpaare in einem Array, die sich in Java zu einer bestimmten Summe addieren

1. Übersicht

In diesem kurzen Tutorial zeigen wir, wie ein Algorithmus zum Finden aller Zahlenpaare in einem Array implementiert wird, dessen Summe einer bestimmten Zahl entspricht. Wir werden uns auf zwei Ansätze für das Problem konzentrieren .

Im ersten Ansatz finden wir alle diese Paare unabhängig von ihrer Eindeutigkeit. In der zweiten finden wir nur die eindeutigen Zahlenkombinationen, wodurch redundante Paare entfernt werden.

Für jeden Ansatz werden zwei Implementierungen vorgestellt - eine herkömmliche Implementierung mit for- Schleifen und eine zweite mit der Java 8 Stream-API.

2. Geben Sie alle passenden Paare zurück

Wir werden ein Array von ganzen Zahlen durchlaufen und alle Paare ( i und j ) finden, die sich mit einem Brute-Force-Nested-Loop-Ansatz zu der angegebenen Zahl ( Summe ) summieren . Dieser Algorithmus hat eine Laufzeitkomplexität von O (n2) .

Für unsere Demonstrationen suchen wir mit dem folgenden Eingabearray nach allen Zahlenpaaren, deren Summe gleich 6 ist :

int[] input = { 2, 4, 3, 3 }; 

Bei diesem Ansatz sollte unser Algorithmus Folgendes zurückgeben:

{2,4}, {4,2}, {3,3}, {3,3}

Wenn wir in jedem der Algorithmen ein Zielpaar von Zahlen finden, die sich zur Zielzahl summieren, sammeln wir das Paar mit der Dienstprogrammmethode addPairs (i, j) .

Der erste Weg, um die Lösung zu implementieren, ist die Verwendung der traditionellen for- Schleife:

for (int i = 0; i < input.length; i++) { for (int j = 0; j < input.length; j++) { if (j != i && (input[i] + input[j]) == sum) { addPairs(input[i], sum-input[i])); } } }

Dies kann etwas rudimentär sein. Schreiben Sie daher auch eine Implementierung mit der Java 8 Stream-API .

Hier verwenden wir die Methode IntStream.range , um einen sequentiellen Zahlenstrom zu generieren. Dann filtern wir sie nach unserer Bedingung: Nummer 1 + Nummer 2 = Summe :

IntStream.range(0, input.length) .forEach(i -> IntStream.range(0, input.length) .filter(j -> i != j && input[i] + input[j] == sum) .forEach(j -> addPairs(input[i], input[j])) ); 

3. Geben Sie alle eindeutigen passenden Paare zurück

In diesem Beispiel müssen wir einen intelligenteren Algorithmus entwickeln, der nur die eindeutigen Zahlenkombinationen zurückgibt und redundante Paare weglässt .

Um dies zu erreichen, fügen wir jedes Element einer Hash-Map hinzu (ohne zu sortieren) und prüfen zuerst, ob das Paar bereits angezeigt wurde. Wenn nicht, rufen wir es ab und markieren es wie gezeigt (setzen Sie das Wertfeld auf null ).

Dementsprechend sollte unser Algorithmus unter Verwendung des gleichen Eingabearrays wie zuvor und einer Zielsumme von 6 nur die verschiedenen Zahlenkombinationen zurückgeben:

{2,4}, {3,3}

Wenn wir eine traditionelle for- Schleife verwenden, haben wir:

Map pairs = new HashMap(); for (int i : input) { if (pairs.containsKey(i)) { if (pairs.get(i) != null) { addPairs(i, sum-i); } pairs.put(sum - i, null); } else if (!pairs.containsValue(i)) { pairs.put(sum-i, i); } }

Beachten Sie, dass diese Implementierung die vorherige Komplexität verbessert, da wir nur eine for- Schleife verwenden, sodass wir O (n) haben .

Lösen wir nun das Problem mit Java 8 und der Stream-API:

Map pairs = new HashMap(); IntStream.range(0, input.length).forEach(i -> { if (pairs.containsKey(input[i])) { if (pairs.get(input[i]) != null) { addPairs(input[i], sum - input[i]); } pairs.put(sum - input[i], null); } else if (!pairs.containsValue(input[i])) { pairs.put(sum - input[i], input[i]); } });

4. Fazit

In diesem Artikel haben wir verschiedene Möglichkeiten erläutert, um alle Paare zu finden, die eine bestimmte Zahl in Java zusammenfassen. Wir haben zwei verschiedene Lösungen gesehen, die jeweils zwei Java-Kernmethoden verwenden.

Wie üblich finden Sie alle in diesem Artikel gezeigten Codebeispiele auf GitHub - dies ist ein Maven-Projekt, daher sollte es einfach zu kompilieren und auszuführen sein.