Median-Berechnung von 2D-Teilarrays

jono

Top Contributor
Hallo !

Java:
  public static double median(int[] m) {
    int middle = m.length / 2;
    if (m.length % 2 == 1) {
      return m[middle];
    } else {
      return (m[middle - 1] + m[middle]) / 2.0;
    }
  }
}
Das wäre die Berechnung des Medians in einem eindimensionalen Array. Ich komme aber einfach nicht darauf, wie ich das für ein 2d implementieren muss.. Also ich möchte ich die einzelnen Mediane von jedem Teilarray.
 
Zuletzt bearbeitet:

MoxxiManagarm

Top Contributor
Ist denn bei dir sichergestellt, dass m sortiert ist?

Ich komme aber einfach nicht darauf, wie ich das für ein 2d implementieren muss.. Also ich möchte ich die einzelnen Mediane von jedem Teilarray.

Ein 2D-Array ist nichts anderes als ein Array von Array. Du kannst das äußere Array also wie ein einfaches Array betrachten und es iterieren. Das Iterationsobjekt ist ein inneres Array, welches du in deine Funktion schubsen kannst.

Java:
int[][] table = new int[m][n];

for (int[] row : mn) {
  double d = median(row);
}
 
Zuletzt bearbeitet:

jono

Top Contributor
Hatte meine Antwort nochmal bearbeitet, schau nochmal bitte
Okay.
Java:
public static double medianInception(double[][] array) {

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length - 1; j++) {
                if (array[i][j] > array[i][j + 1]) {
                    double temp = array[i][j];
                    array[i][j] = array[i][j + 1];
                    array[i][j + 1] = temp;

                }
            }
        }

        for (int m = 0; m < array.length; m++) {
            for (int n = 0; n < array.length; n++) {
                int middle = array.length / 2;
                if (array.length % 2 == 1) {
                    return array[middle];
                } else {
                    return (array[middle - 1] + array[middle]) / 2.0;
                }
            }
        }

    }

}
Es wird ein 2D-Array sortiert. Dann wird ja hier die Median-Berechnung durchgeführt. (Die ja so noch nicht richtig ist)
int[][] table = new int[m][n]; for (int[] row : mn) { double d = median(row); }
Ich kann mir noch nicht erklären, wie ich das jetzt noch richtig in den obigen Code einbringen soll.,
 

jono

Top Contributor
Java:
for (int m = 0; m < array.length; m++) {
            for (int n = 0; n < array.length; n++) {
                int middle = array.length / 2;
                if (array.length % 2 == 1) {
                    array[m][n];
                    for(double[] row:mn) {
                        double[] d = medianInception(row);
                    }
                } else {
                    return (array[middle - 1] + array[middle]) / 2.0;
                }
            }
        }
Wäre so ein kleiner Ansatz von mir..
 

MoxxiManagarm

Top Contributor
Ich habe folgende Anmerkungen
1. Das ist keine Sortierung, zumindest nicht vollumfänglich. 2 3 1 würde z.B. nicht richtig sortiert werden, weil 3 und 1 zwar vertauscht werden würden, jedoch nicht dann auch 1 und 2
2. Bei der ersten inneren Schleife hast du korrekt die Größe von array[i] verwendet. Bei der zweiten inneren Schleife jedoch nicht. Das führt zu NPE, falls du weniger Spalten als Reihen hättest
3. Bist du dir sicher, dass die Methode einen einzelnen double Wert zurückgeben soll? Ich meine ja, dass das eher ein double Vektor (also ein double Array) sein sollte.
 

jono

Top Contributor
1. Das ist keine Sortierung, zumindest nicht vollumfänglich. 2 3 1 würde z.B. nicht richtig sortiert werden, weil 3 und 1 zwar vertauscht werden würden, jedoch nicht dann auch 1 und 2
Was muss ich da denn noch ändern? Genau diesen Algorithmus haben wir vorgelegt bekommen, der auch nachdem ich mir über den Ablauf von dem Algorithmus Gedanken gemacht habe, Sinn gemacht hat.
Java:
for(int i = 0; i < array.length-1; i++){
             for(int j = i + 1; j > 0; j--){
               if(array[i][j] < array[i-1][j]){ 
                   double temp = array[i-1][j];
                   array[i-1][j] = array[i][j];
                   array[i][j] = temp;                  
               }
             }
        }
So muss es stimmen
Bei der ersten inneren Schleife hast du korrekt die Größe von array[i] verwendet. Bei der zweiten inneren Schleife jedoch nicht. Das führt zu NPE, falls du weniger Spalten als Reihen hättest
Worauf bezieht sich das genau?
Bist du dir sicher, dass die Methode einen einzelnen double Wert zurückgeben soll? Ich meine ja, dass das eher ein double Vektor (also ein double Array) sein sollte.
Nein. Es sollen die Mediane der 2D-Teilarrays berechnet werden. Diese widerrum sollen in ein Eindimensionales kopiert werden. Und aus dem Eindimensionalen widerrum soll der Median berechent werden, weshalb der Rückgabetyp so stimmt.
 
Zuletzt bearbeitet:

MoxxiManagarm

Top Contributor
Was muss ich da denn noch ändern? Genau diesen Algorithmus haben wir vorgelegt bekommen, der auch nachdem ich mir über den Ablauf von dem Algorithmus Gedanken gemacht habe, Sinn gemacht hat
Das kommt ganz darauf an, welches Sortierverfahren du einsetzen willst, es gibt viele.

Worauf bezieht sich das genau?

Auf die innere Schleife mit n

Java:
for (int j = 0; j < array[i].length - 1; j++) { // hier ist korrekt array[i] in der Bedingung
for (int n = 0; n < array.length; n++) { // hier fehlt das, es müsste array[m] sein

Nein. Es sollen die Mediane der 2D-Teilarrays berechnet werden. Diese widerrum sollen in ein Eindimensionales kopiert werden. Und aus dem Eindimensionalen widerrum soll der Median berechent werden, weshalb der Rückgabetyp so stimmt.

Aha! Jetzt kommen wir langsam auf einen Nenner. Du hast die Methode doch schon für einen 1D-Median. Die kannst du wiederverwenden.

Java:
public double median1D(double[] array1D) {
  // deine Logik von oben, ich würde allerdings auch die Sortierung von dem Array hier machen
}

public double median2D(double[][] array2D) {
  double[] medianPerRow = new double[array2D.length];
  for (int i = 0; i < array2D.length; i++) {
    medianPerRow[i] = median1D(array2D[i]);
  }
  return median1D(medianPerRow);
}

So muss es stimmen
Da ist aber auch einiges anders als bei dir im Code oben
 
Zuletzt bearbeitet:

jono

Top Contributor
Java:
for(int i = 0; i < array[i].length; i++){
             for(int j = 0; j < array[j].length; j++){
               if (array[i][j] > array[i][j + 1]) {
                   double temp = array[i][j];
                   array[i][j] = array[i][j + 1];
                   array[i][j + 1] = temp;

               }                 
               }
             }
Ist das jetzt so richtig ? Tue mich damit ziemlich schwer ^^...
 

MoxxiManagarm

Top Contributor
Ist das jetzt so richtig ? Tue mich damit ziemlich schwer ^^...

Nein du sollst nicht das 2D-Array sortieren, sondern nur das einzelne Array jeweils.

Deine Schleifen kommen Bubblesort sehr nahe, aber wie gesagt nur ein einzelnes Array, kein 2D-Array. Hier der Code von Wikipedia
Code:
bubbleSort(Array A)
  for (n=A.size; n>1; --n){
    for (i=0; i<n-1; ++i){
      if (A[i] > A[i+1]){
        A.swap(i, i+1)
      } // Ende if
    } // Ende innere for-Schleife
  } // Ende äußere for-Schleife
 

MoxxiManagarm

Top Contributor
Schau dir nochmal Antwort #9 an. Die 2D-Methode sollte so wie sie ist schon richtig sein. Du musst nur die Benennung noch anpassen. Du baust dir die Hilfsmethode für 1D zusammen und die Hilfsmethode sortiert das übergebene Array auch mit Bubblesort. Den Code für Bubblesort hast du ja auch schon, du darfst nur nicht den Fehler machen versuchen Bubblesort auf dein 2D-Array anzuwenden.
 

MoxxiManagarm

Top Contributor
Beispiel

Der Median soll berechnet werden von
1 3 2
2 5 6
9 2 8
4 4 4

Dann gehst du zuerst Reihe für Reihe (jeweils ein Vektor, z.B. 1 3 2) durch und erhältst den Vektor
2
5
8
4

Diesen Vektor kannst du wie die Reihenvektoren berechnen und erhältst 4.5
 

fhoffmann

Top Contributor
Wie schaffe ich es nur die Reihen zu sortieren..
Du hast doch bereits eine Methode, um ein eindimensionales Array zu sortieren.

Ein zweidimensionales Array ist ein Array von eindimensionalen Arrays! (Diesen Satz solltest du verstehen!)
Du kannst das zweidimensionale Array also durchiterieren und für jeden Eintrag die Sortier-Methode für ein eindimensionales Array aufrufen.
 

jono

Top Contributor
Java:
boolean swapped ;
         do {
         swapped = false ;
         for (int i = 1; i < array.length ; i ++)
         if ( array[i - 1] > array [i]) { 
         double swap = array [i];
         array[ i ] = array [ i - 1];
         array[ i - 1] = swap ;
           swapped = true ;
         }
         } while (swapped) ; // nicht richtig formatiert, Tastatur reagiert irgendwie nicht auf die Tastenkombination(Strg, Shift & F)
Das wäre ja dann die Sortiermethode für ein Eindimensionales.
Ein zweidimensionales Array ist ein Array von eindimensionalen Arrays! (Diesen Satz solltest du verstehen!)
Du kannst das zweidimensionale Array also durchiterieren und für jeden Eintrag die Sortier-Methode für ein eindimensionales Array aufrufen.
Ja, den Satz verstehe ich. Um das Zweidimensionale durchzuiterieren, müsste ich doch jetzt noch eine for-Schleife hinzufügen, oder nicht?
Was fehlt noch @fhoffmann
 

mihe7

Top Contributor
müsste ich doch jetzt noch eine for-Schleife hinzufügen, oder nicht?
Äh:
Du hast die Methode doch schon für einen 1D-Median. Die kannst du wiederverwenden.
Schau dir nochmal Antwort #9 an. Die 2D-Methode sollte so wie sie ist schon richtig sein.
Das Zusammenkopieren der Lösungen bekommst Du selbst hin, oder sollen das @fhoffmann bzw. @MoxxiManagarm für Dich auch noch übernehmen?
 

jono

Top Contributor
Das Zusammenkopieren der Lösungen bekommst Du selbst hin, oder sollen das @fhoffmann bzw. @MoxxiManagarm für Dich auch noch übernehmen?
Nein, darum geht es mir nicht. In #9 steht aber nicht, wie ich die Teilarrays jetzt sortiere. Mein Sortierverfahren sollte in Form von bubbleSort das 2D array sortieren. Mir ist gerade aufgefallen beim richtigen Hinschauen, dass ich etwas durcheinander geworfen hatte.
Wie könnte ich das von #9 jetzt aber in einer Methode, etwa in der median2D Methode alles in einem implementieren. Da in der Aufgabenstellung nichts von der Erlaubnis von Hilfsmethoden steht, denn normalerweise steht es dabei, wenn erlaubt.
 

MoxxiManagarm

Top Contributor
Mein Sortierverfahren sollte in Form von bubbleSort das 2D array sortieren.
Du kannst ein 2D-Array aber nicht sortieren, du kannst nur einen Vektor sortieren, also eine Zeile oder eine Spalte. Du wirst trotzdem das 2D-Array iterieren und jede Zeile in sich sortieren müssen. Das iterieren ist eine Schleife, Bubblesort sind 2. Wenn du also wirklich darauf bestehst dann brauchst du 3 verschachtelte Schleifen.
 

jono

Top Contributor
Du kannst ein 2D-Array aber nicht sortieren, du kannst nur einen Vektor sortieren, also eine Zeile oder eine Spalte.
Okay verstehe ich.
Das iterieren ist eine Schleife, Bubblesort sind 2. Wenn du also wirklich darauf bestehst dann brauchst du 3 verschachtelte Schleifen.
Java:
for(int i = 0; i < array[i].length; i++){
             for(int j = 0; j < array[j].length; j++){
                           for(int k = 0; k < array[j].length) {
               if (array[i][j] > array[i][j + 1]) {
                   double temp = array[i][j];
                   array[i][j] = array[i][j + 1];
                   array[i][j + 1] = temp;

               }                 
               }
             }
So?
 

MoxxiManagarm

Top Contributor
Jetzt hast du ein k aber verwendest es nicht.

Ich denke du muss versuchen dir Bubblesort nochmal vor Augen zu halten.

Beispiel

5 2 3 1 4

Im Ersten Durchlauf wird das 1. Element mit allen anderen verglichen und ggf. vertauscht.
5 vs 2 --> swap ( 2 5 3 1 4 )
2 vs 3
2 vs 1 --> swap ( 1 5 3 2 4 )
1 vs 4

1 5 3 2 4

Im zweiten Durchlauf dann das 2. Element mit den nachfolgenden Elementen (an erster Stelle ist jetzt schon das niedrigste)
5 vs 3 --> swap ( 1 3 5 2 4 )
3 vs 2 --> swap ( 1 2 5 3 4 )
2 vs 4

1 2 5 3 4

Im dritten Durchlauf das 3. Element mit den Nachfolgeelementen
5 vs 3 --> swap (1 2 3 5 4)
3 vs 4

1 2 3 5 4

Und gleiches Prinzip
5 vs 4 --> swap ( 1 2 3 4 5)
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Nein, darum geht es mir nicht.
Du bist lustig, im überübernächsten Satz fragst Du bereits wieder, wie Du jetzt alles in eine Methode bekommst. Ich glaube Dir sogar, dass es Dir gar nicht ums Kopieren geht und das war von mir auch nicht böse gemeint, aber wenn Du Dir jede Lösung bis zum bitteren Ende vorkauen lässt, wirst Du nie selbständig eine finden. Man hat das Gefühl, Du stocherst irgendwie in der Gegend rum, weißt aber gar nicht, was Du da eigentlich tust.
 

jono

Top Contributor
Jetzt hast du ein k aber verwendest es nicht
Also: mit i und j möchte ich Spalten und Zeilen sortieren. Mit dem k, hast du gesagt, soll iteriert werden.
for(int i = 0; i < array.length; i++){ for(int j = 0; j < array[j].length; j++){ for(int k = 0; k < array[j].length) { if (array[j] > array[j + 1]) { double temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } }
Java:
for(int i = 0; i < array[i].length; i++){
for(int j = 0; j < array[j].length; j++){
for(int k = 0; k < array[i].length) {
if (array[i][j] > array[i][j + 1]) {
double temp = array[i][j];
array[i][j] = array[i][j + 1];
array[i][j + 1] = temp;
}
}
}
Ich denke so ist es auch nicht richtig. Warum muss ich denn jetzt noch iterieren; Keine Ausrede: Aber ich finde die Aufgabe vom Verständnis bzw. Prinzip nicht schwer. Ich hab einfach keine Ahnung, wie ich jetzt noch richtig iterieren soll..
 

jono

Top Contributor
Du bist lustig, im überübernächsten Satz fragst Du bereits wieder, wie Du jetzt alles in eine Methode bekommst. Ich glaube Dir sogar, dass es Dir gar nicht ums Kopieren geht und das war von mir auch nicht böse gemeint, aber wenn Du Dir jede Lösung bis zum bitteren Ende vorkauen lässt, wirst Du nie selbständig eine finden. Man hat das Gefühl, Du stocherst irgendwie in der Gegend rum, weißt aber gar nicht, was Du da eigentlich tust.
Ich weiß schon, was ich tue. Ich weiß auch, dass es nicht so wirkt. Aber das ist natürlich auch mir geschuldet, keine Frage.
Jedoch kamen wir erst eben darauf, dass es dann doch widerrum 3 Schleifen benötigt.
 

fhoffmann

Top Contributor
Warum machst du es dir denn so schwer???
Wenn du bereits eine Methode hast:
Java:
public static void sortiere(int[] arr) {
    //
}
kannst du doch einfach eine neue Methode schreiben:
Java:
public static void sortiereZeilen(int[][] arr2) {
    for (int zeile = 0; zeile < arr2.length; ++zeile) {
        sortiere(arr2[zeile]);
    }
}
Und genauso kannst du für jede Zeile den Median berechnen.
 

MoxxiManagarm

Top Contributor
Da in der Aufgabenstellung nichts von der Erlaubnis von Hilfsmethoden steht, denn normalerweise steht es dabei, wenn erlaubt.

Ich möchte nochmal darauf plädieren, dass du dir Hilfsmethoden anlegst.
a) Der Prof wird das nicht ein Leben lang drunterschreiben. Irgendwann muss es selbstverständlich sein. Und für diese Aufgabe wäre es echt schrecklich, wenn sie nicht erlaubt sein würden.
b) Und selbst wenn du es nicht darfst, machs doch trotzdem erst. Es erleichtert die Struktur und damit deine Gedanken. Den Code kannst du doch anschließend auch aus den Hilfsmethoden an die entsprechenden Stellen kopieren
 

jono

Top Contributor
Als Ergebnis erhalte ich 5.0., was ja eigentlich korrekt ist. Die Aufgabenstellung für die Nachvollziehbarkeit:

Zunächst sollen die Mediane der Teilarrays berechnet werden. Beachten Sie, dass diese unsortiert sein können! Wie man den Median bestimmt können Sie beispielsweise auf Wikipedia nachlesen: https://de.wikipedia.org/wiki/Median. Zum Sortieren der einzelnen Arrays verwenden Sie BubbleSort, InsertionSort oder SelectionSort. Deren Mediane werden dann jeweils in ein neues (eindimensionales) Array eingetragen, von diesem wiederum erneut der Median berechnet und anschließend zurückgegeben wird. Falls eines der Arrays null oder leer ist, dann soll Double.NaN zurückgegeben werden.
Hinweis: Bei der Abfrage ob ein Array null oder leer ist, muss null immer zuerst abgefragt werden, sonst tritt eine NullPointerException auf!
Wie aber kommt es jetzt zu den Fehlermeldungen:

Java:
1) testSonderfallLeer(PublicTests)
java.lang.ArrayIndexOutOfBoundsException: Index -1 out of bounds for length 0
    at Functionality.bubbleSort(Functionality.java:33)
    at Functionality.medianInception(Functionality.java:40)
    at PublicTests.testSonderfallLeer(PublicTests.java:29)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.base/java.lang.reflect.Method.invoke(Method.java:566)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runners.Suite.runChild(Suite.java:128)
    at org.junit.runners.Suite.runChild(Suite.java:27)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
    at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
    at org.junit.runner.JUnitCore.main(JUnitCore.java:36)
2) testSonderfallNull(PublicTests)
java.lang.NullPointerException
    at Functionality.bubbleSort(Functionality.java:11)
    at Functionality.medianInception(Functionality.java:40)
    at PublicTests.testSonderfallNull(PublicTests.java:22)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.base/java.lang.reflect.Method.invoke(Method.java:566)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runners.Suite.runChild(Suite.java:128)
    at org.junit.runners.Suite.runChild(Suite.java:27)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
    at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
    at org.junit.runner.JUnitCore.main(JUnitCore.java:36)
3) testNormal(PublicTests)
java.lang.AssertionError: expected:<-3.5> but was:<NaN>
    at org.junit.Assert.fail(Assert.java:88)
    at org.junit.Assert.failNotEquals(Assert.java:834)
    at org.junit.Assert.assertEquals(Assert.java:553)
    at org.junit.Assert.assertEquals(Assert.java:683)
    at PublicTests.testNormal(PublicTests.java:17)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.base/java.lang.reflect.Method.invoke(Method.java:566)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runners.Suite.runChild(Suite.java:128)
    at org.junit.runners.Suite.runChild(Suite.java:27)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
    at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
    at org.junit.runner.JUnitCore.main(JUnitCore.java:36)
?
Java:
public class calculateMedian {

    public static void main(String[] args) {
        double[][] arr = { { 2, 5, 3, 8, 6 }, { 2, 5, 3, 8, 6 } };
        System.out.println(medianInception(arr));
    }

    public static double bubbleSort(double[] arr) {
        for(int i = 0; i < arr.length; i++) {
            if(arr == null || arr[i] == 0) {
            return Double.NaN;
            }
        }
        
        boolean swapped;
        do {
            swapped = false;
            for (int i = 1; i < arr.length; i++)
                if (arr[i - 1] > arr[i]) {
                    double swap = arr[i];
                    arr[i] = arr[i - 1];
                    arr[i - 1] = swap;
                    swapped = true;
                }
        } while (swapped);

        int middle = arr.length / 2;
        if (arr.length % 2 == 1) {
            return arr[middle];
        } else {
            return (arr[middle - 1] + arr[middle]) / 2.0;
        }
    }

    public static double medianInception(double[][] array) {
        double[] a = new double[array.length];
        for (int i = 0; i < array.length; ++i) {
            a[i] = bubbleSort(array[i]);
        }
        int median = a.length / 2;
        if (a.length % 2 == 1) {
            return a[median];
        }
        return (a[median - 1] + a[median]) / 2;

    }
}
 

jono

Top Contributor
Java:
if (arr == null || arr.length == 0) {
            return Double.NaN;
        }
Ich habe die Anweisung dann jetzt so formuliert.
Warum erscheint diese Meldung noch..?
Java:
1) testSonderfallNull(PublicTests)
java.lang.AssertionError: expected:<NaN> but was:<5.5>
    at org.junit.Assert.fail(Assert.java:88)
    at org.junit.Assert.failNotEquals(Assert.java:834)
    at org.junit.Assert.assertEquals(Assert.java:553)
    at org.junit.Assert.assertEquals(Assert.java:683)
    at PublicTests.testSonderfallNull(PublicTests.java:23)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.base/java.lang.reflect.Method.invoke(Method.java:566)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runners.Suite.runChild(Suite.java:128)
    at org.junit.runners.Suite.runChild(Suite.java:27)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
    at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
    at org.junit.runner.JUnitCore.main(JUnitCore.java:36)
 

MoxxiManagarm

Top Contributor
Übrigens, ich habe gerade festgestellt, dass du in diese Bedingung nie reinlaufen wirst, warum weiß ich nicht genau, aber das könnte auch bei dir passieren oder passiert sein.

Java:
double d = Double.NaN;
if (d == Double.NaN) {
  // wird nicht erreicht
}

Du musst für d en Vergleich die Double::isNaN Methode aufrufen.
 

MoxxiManagarm

Top Contributor
Die isNaN Methode hast du da ja auch nicht verwendet...
Ich habe ja auch das negativ-Beispiel aufgeführt. In dem Inline Kommentar steht dass das innere der if-Bedingung nicht erreicht wird. Richtig wäre es mit isNaN. Du wirst es nicht unbedingt brauchen, kommt ganz darauf an wie du den Code aufziehst. Ich wollte es dir nur schon mitgeben, falls du es brauchen wirst.
 

jono

Top Contributor
Wenn du die Abfrage immernoch in der bubblesort Methode machst wird dir das nichts bringen
Also, ich habe die Abfrage jetzt in die medianInception-Methode geschrieben:
Java:
public static double medianInception(double[][] array) {
        
        double[] a = new double[array.length];
        
        
        for (int i = 0; i < array.length; ++i) {
            a[i] = bubbleSort(array[i]);
        }
        
        if (a == null || a.length == 0) {
            return Double.NaN;
        }
        
        int median = a.length / 2;
        if (a.length % 2 == 1) {
            return a[median];
        }
        return (a[median - 1] + a[median]) / 2.0;

    }
isNaN verwenden zu sollen kann ich immer noch nicht ganz nachvollziehen, denn es heißt ja in der Aufgabenstellung, dass einfach nur abgefragt werden soll, ob das array null || array.length == 0 ist. Wenn ja, dann soll Double.NaN zurückgeliefert werden...
 

MoxxiManagarm

Top Contributor
Du hast ja immernoch einen Rückgabewert im bubblesort. Tu mir den Gefallen und lies nochmal alle Kommentare, versuche sie zu verstehen. Aktuell machst du nur Müll, man hat wirklich das Gefühl du stocherst nur so herum. Und das ist nicht mal böse gemeint.

isNaN verwenden zu sollen kann ich immer noch nicht ganz nachvollziehen, denn es heißt ja in der Aufgabenstellung, dass einfach nur abgefragt werden soll, ob das array null || array.length == 0 ist. Wenn ja, dann soll Double.NaN zurückgeliefert werden...

Das liegt daran, dass du vermutlich einen Fall vergisst. Es kann sowohl das 2D-Array null oder leer sein, als auch jedes Teilarray. Die Teilarrays kannst du an verschiedenen Stellen prüfen. Die meisten Varianten würden Double::isNaN brauchen, jedoch nicht alle.

Beispiel
Java:
double[][] arr = {null,{2, 5, 6},{9, 2, 8},{4, 4, 4}}; // Teilarray ist null
double[][] arr = {}; // 2D-Array ist leer
 

jono

Top Contributor
Und was hat die Berechnung eines Medians in einer solchen Merhode zu tun.
@fhoffmann Ich habe die Berechnung dort hingeschrieben, weil ich dachte, dass es wie mit der Sortierung ist. Wenn ich dementsprechend sozusagen auch in der bubbleSort-Methode auch den Median des sortierten Arrays berechne, dass sich das dann auch auf die Teilarrays des zweidimensionalen Arrays der medianInception-Methode auswirkt. Sozusagen, dass dann die Mediane der Teilarrays direkt in
for (int i = 0; i < array.length; ++i) { a= bubbleSort(array); }

a geladen werden...
 

MoxxiManagarm

Top Contributor
Ich habe keine Lust mehr und gebe auf. Ich habe die Hoffnung, dass du es vielleicht mit dem fertigen Beispiel besser verstehst was wir alle bisher geschrieben haben. Bitte öffne das nur, wenn du mir versprichst alles noch einmal nachzuvollziehen.

Java:
private static void bubbleSort(double[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                // swap
                double temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

private static double medianInception(double[] arr) {
    // sort the array (byReference)
    bubbleSort(arr);

    // return the median
    int middle = arr.length / 2;
    if (arr.length % 2 == 1) {
        return arr[middle];
    } else {
        return (arr[middle - 1] + arr[middle]) / 2.0;
    }
}

public static double medianInception(double[][] arr) {
    // return NaN if 2D-Array is null or empty
    if (arr == null || arr.length == 0) {
        return Double.NaN;
    }

    // return NaN if Sub-Array is null or empty
    for (double[] subArr : arr) {
        if (subArr == null || subArr.length == 0) {
            return Double.NaN;
        }
    }

    // calculate the median of each sub-array and store it in a new array
    double[] mediane = new double[arr.length];
    for (int i = 0; i < arr.length; i++) {
        mediane[i] = medianInception(arr[i]);
    }

    // return the median of the new array
    return medianInception(mediane);
}
 
Zuletzt bearbeitet:
Ähnliche Java Themen
  Titel Forum Antworten Datum
B Berechnung Median mit Methode Java Basics - Anfänger-Themen 7
J Array Median bestimmen Java Basics - Anfänger-Themen 6
4 Median ohne Array Rausbekommen Java Basics - Anfänger-Themen 8
Screen Wie geringste Absolutdifferenz zum Median bestimmen? Java Basics - Anfänger-Themen 8
F Median berechnen, Benutzereingabe Problem! Java Basics - Anfänger-Themen 14
L Median berechnen Java Basics - Anfänger-Themen 17
StrikeTom Median ausrechnen Java Basics - Anfänger-Themen 3
A Median, Standardabweichung Java Basics - Anfänger-Themen 5
I File Uploader... Statusanzeige, Berechnung des Status etc. Java Basics - Anfänger-Themen 0
Bugs Bunny Fehlerhafte Berechnung beim erneuten Durchlaufen der Schleife Java Basics - Anfänger-Themen 5
Jamie logische Verknüpfung zur Schaltjahr-Berechnung Java Basics - Anfänger-Themen 30
Stephan_kl Reihenwert-Berechnung, Ergebnis mit vorherigem Ergebnis vergleichen Java Basics - Anfänger-Themen 11
Abraham42 Berechnung der Kühlung Java Java Basics - Anfänger-Themen 12
S Hashcode-Berechnung + ^ Java Basics - Anfänger-Themen 2
F Tabelle - Berechnung Rang Java Basics - Anfänger-Themen 2
B Berechnung der Position von Kinderelemente von einem Elternknoten Java Basics - Anfänger-Themen 23
S Berechnung der sleep time ist falsch Java Basics - Anfänger-Themen 46
S Switch-Case zur Berechnung der Einkommensteuer Java Basics - Anfänger-Themen 15
F Berechnung der Rektaszension und Deklination eines Sterns Java Basics - Anfänger-Themen 7
2 Taschenrechner mit GUI Problem bei der Berechnung Java Basics - Anfänger-Themen 8
V Erste Schritte Pi Berechnung Java Basics - Anfänger-Themen 47
M Berechnung der Reststrecke bei Graphen Java Basics - Anfänger-Themen 1
V Algorithmus zur fortlaufenden Berechnung des duechscjnt Java Basics - Anfänger-Themen 1
B Berechnung zu einer Schleife formen Java Basics - Anfänger-Themen 6
CptK Methoden Berechnung von Anfangsgeschwindigkeit und Winkel Java Basics - Anfänger-Themen 27
K Erste Schritte Berechnung der Summe zweier Arrays Java Basics - Anfänger-Themen 15
S Erste Schritte Berechnung des Paketportos - Problem/Frage Java Basics - Anfänger-Themen 52
J Gleitkommazahlen, Berechnung von pi Java Basics - Anfänger-Themen 4
J Berechnung liefert falsches Ergebnis Java Basics - Anfänger-Themen 2
kilopack15 Verzweiflung wegen Berechnung mit Multithreading Java Basics - Anfänger-Themen 1
A Die Werte zur Berechnung müssen als Parameter übergeben werden? Java Basics - Anfänger-Themen 7
Salo Berechnung von Winkeln Java Basics - Anfänger-Themen 28
M Restbuchwert Berechnung geht nicht Java Basics - Anfänger-Themen 45
Ghostman1711 Pi berechnung Methode aufrufen Java Basics - Anfänger-Themen 2
L Rekursive Methode zur Berechnung der Potenz q hoch p Java Basics - Anfänger-Themen 17
beatles Operatoren Operatoren - Berechnung Java Basics - Anfänger-Themen 40
K Best Practice Algorithmus für Berechnung von Zahlenreihenfolge Java Basics - Anfänger-Themen 12
N Verzögerte Berechnung "Lazy" Java Basics - Anfänger-Themen 8
J Erste Schritte Rundungsproblem - Berechnung Notendurchschnitt Java Basics - Anfänger-Themen 13
S Variablen Vektor zur Berechnung verwenden Java Basics - Anfänger-Themen 4
T Java double berechnung fehler Java Basics - Anfänger-Themen 2
M Berechnung in Java Java Basics - Anfänger-Themen 4
S Berechnung der Arbeitstage in einem Zeitraum Java Basics - Anfänger-Themen 9
E Problem bei rekursiver Berechnung des Binomialkoeffizienten Java Basics - Anfänger-Themen 5
T Iterative Pi Berechnung in Rekursive Java Basics - Anfänger-Themen 2
S Double, int, Berechnung Java Basics - Anfänger-Themen 3
C Nach Berechnung runden und Wert ausgeben Java Basics - Anfänger-Themen 7
E Berechnung für Shop einbinden Java Basics - Anfänger-Themen 8
S Klassen Formel zur Berechnung .... Bitte um Hilfe Java Basics - Anfänger-Themen 7
S Euklid Algorithmus zur Berechnung des GGTs Java Basics - Anfänger-Themen 2
OnDemand Berechnung in die start und paint Methode eines Applets Java Basics - Anfänger-Themen 28
P Schleife zur Berechnung von einer Summe Java Basics - Anfänger-Themen 16
F Berechnung einer linearen Abschreibung Java Basics - Anfänger-Themen 5
E Berechnung von Punkten Java Basics - Anfänger-Themen 4
D Berechnung des Abstandes von zwei Punkten in einem Koordinatensystem Java Basics - Anfänger-Themen 14
A Methoden PI-Berechnung Java Basics - Anfänger-Themen 22
S Erste Schritte Berechnung mit Daten aus CSV und Date Objekt Java Basics - Anfänger-Themen 2
C Programm zur Berechnung der Spur einer Matrix Java Basics - Anfänger-Themen 4
P Pythagoras Baum - Berechnung der Punkte Java Basics - Anfänger-Themen 9
A Erste Schritte Steuer Berechnung, Alters Abhängig Java Basics - Anfänger-Themen 5
T Erste Schritte Berechnung von gerade und ungerade Zahlen Java Basics - Anfänger-Themen 10
J Erste Schritte Berechnung Ratten vermehrung Java Basics - Anfänger-Themen 4
P falsches ergebnis bei einfacher berechnung Java Basics - Anfänger-Themen 3
T Iterative Berechnung einer Satellitenbahn Java Basics - Anfänger-Themen 20
M Java Berechnung mit mehreren Lösungen? Java Basics - Anfänger-Themen 9
D Nullstellen-Berechnung Java Basics - Anfänger-Themen 10
L Fehlermeldung bei falscher Berechnung anzeigen Java Basics - Anfänger-Themen 31
A berechnung multiplikatives inverses Java Basics - Anfänger-Themen 5
J Berechnung des aktuellen Alters auf Basis des Geburtstags Java Basics - Anfänger-Themen 45
J Datentypen Fehler bei Berechnung mit Double und Int-Werten Java Basics - Anfänger-Themen 22
G Berechnung von Winkeln mit Cosinussatz Java Basics - Anfänger-Themen 2
B Arrays verwenden für Berechnung Java Basics - Anfänger-Themen 3
R Merkwürdige Modulo Berechnung Java Basics - Anfänger-Themen 7
B Hausaufgabe Berechnung quadratischer Funktion Java Basics - Anfänger-Themen 16
U Alter Berechnung + sortierung Java Basics - Anfänger-Themen 6
P Berechnung wird nicht durchgeführt Java Basics - Anfänger-Themen 2
D Berechnung von Ostern und Ramadan! Java Basics - Anfänger-Themen 24
N Algorithmus für Berechnung einer Quersumme Java Basics - Anfänger-Themen 9
D Berechnung von Geldausgabe Java Basics - Anfänger-Themen 22
F Berechnung von Kugeln! Java Basics - Anfänger-Themen 9
M rekursive Funktion zur Berechnung der Spiegelzahl Java Basics - Anfänger-Themen 7
S Hausaufgabe: Java-Programm schreiben zur Berechnung von x und y Java Basics - Anfänger-Themen 9
Y Ergebnis einer Berechnung an die Main Methode übergeben Java Basics - Anfänger-Themen 11
Semox Ersten Wert eines Intervalls bei Berechnung einschließen Java Basics - Anfänger-Themen 8
J Logarithmische Berechnung und Arrays Java Basics - Anfänger-Themen 2
B LinkedList - Berechnung des Produkts Java Basics - Anfänger-Themen 6
B Berechnung von Preisen per Java-Programm Java Basics - Anfänger-Themen 27
M Alters berechnung aus Geburtsjahr aus dem Buch Java Basics - Anfänger-Themen 5
O Fehler in der String-Distanz-Berechnung Java Basics - Anfänger-Themen 5
-horn- "Berechnung vorwärts, Optimierung rückwärts?" - Wie würdet ihr das machen? Java Basics - Anfänger-Themen 8
P iterative Berechnung Java Basics - Anfänger-Themen 9
1 Berechnung von PI mithilfe von Buffons Nadelproblem Java Basics - Anfänger-Themen 2
G Berechnung zwei Komplexen Zahlen Java Basics - Anfänger-Themen 34
N Rekursive Berechnung der Höhe eines binären Baumes Java Basics - Anfänger-Themen 4
J Programm für interaktive Berechnung von Temperaturverläufen Java Basics - Anfänger-Themen 9
K Annährende ganzzahlige Berechnung der Wurzel Java Basics - Anfänger-Themen 8
L Berechnung von Perioden Java Basics - Anfänger-Themen 4
D einfach berechnung einer onlinezeit Java Basics - Anfänger-Themen 25
S Euklid Klasse mit Methoden zur Berechnung des ggT Java Basics - Anfänger-Themen 23
G Frage zur Primzahlen berechnung Java Basics - Anfänger-Themen 11

Ähnliche Java Themen

Neue Themen


Oben