Zweidimensionales array kopieren und in eindimensionales überführen

[tfausw]

Wenn man sich einmal klar macht, dass man die Anzahl der Arrays abziehen will, dann kommt man auch sehr schnell darauf, dass die Anzahl doch einfach array.length ist und dann sollte einem die -1 nicht erst in den Kopf kommen....

Habe ich tatsächlich gerade. Jedoch nach wie vor irgendwo einen Rechenfehler. Und doch ich mache mir sogar sehr viele Gedanken über die Hinweise.

Ansonsten frage ich mich, ob wir dies nicht zu komplex machen. Ich würde die -1 direkt in der Schleife abziehen - und zwar nur, wenn das Array überhaupt Elemente hat. Was passiert denn, wenn ein Array leer ist? Da fällt er doch dann wieder auf die Nase ...

Habe ich tatsächlich auch, klappt nur nicht so ganz..

for (int i = 0; i < array.length; i++) {
    if (array == null || array.length == 0) {
        return new int[] {}; // leeres Array der Länge 0 ausgeben
    }
}

 

[mihe7]

Aber es ist ein herumraten. Und dafür, dass er doch schon fast fertig war und nur eine Kleinigkeit geändert werden muss, ist es erstaunlich, dass immer noch falsche Ideen kommen und man eben so Hinweise nicht befolgen will.

Leider. Ich verstehe es ehrlich auch nicht. Aber da es gleich drei Leute sind, die hier ein Problem haben, zweifle ich langsam an mir selbst. *Heul-Smiley*

 

[tfausw]

Leider. Ich verstehe es ehrlich auch nicht. Aber da es gleich drei Leute sind, die hier ein Problem haben, zweifle ich langsam an mir selbst. *Heul-Smiley*

Ich glaube es liegt weniger an euch, ich für meinen Teil verzweifle selber fast, obwohl man ja scheinbar nah dran ist und vermutlich denkt man was ähnliches, drückt es nur anders aus oder denkt zu komplex.

 

[kneitzel]

oder denkt zu komplex.

Ja, das dürfte es aus meiner Sicht sein. Daher wäre meine Tendenz, wirklich mehr in Methoden zu unterteilen.

Wollen wir dies mal versuchen? Wir sind schon bei #154 - also können wir jetzt auch richtig den Thread nutzen.

1. Schreib eine Methode public static int getElementCountOfArrayWithIgnoredElements(int array[], int ignoreCount)
==> Also es wird ein Array gegeben (z.B. {1, 2, 3}) und die Info, wie viele Elemente ignoriert werden sollen (z.B. 1) und dann soll zurück gegeben werden, wie viele Elemente da zu berücksichtigen sind. (In dem Beispiel wäre meine Erwartungshaltung 2.
Bedenke, dass evtl. mehr Elemente ignoriert werden sollen als vorhanden sind. Dann wäre 0 zurück zu geben.

Kannst Du diese Methode mal hier rein schreiben?

 

[mihe7]

Kannst Du diese Methode mal hier rein schreiben?

Puh, gerade noch rechtzeitig gesehen - ich war gerade dabei seinen Code umstrukturiert zu posten

 

[kneitzel]

Und wenn, dann wäre es auch nicht so wild. Aber ich habe die Hoffnung, dass es etwas bringt, wenn wir wirklich hier mal alles in einzelne Methoden packen. Denn die Algorithmen selbst bekommen sie ja zumindest teilweise hin.

 

[tfausw]

Kannst Du diese Methode mal hier rein schreiben?

public static int shortMethod(int array[], int ignoreCount) {
        if (ignoreCount > array.length) return 0;
        
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            count = array[i];
                
        } 
        int result = count - ignoreCount;
        return result;
    }

Wäre meine Lösung.

 

[mihe7]

Aber wie bekomme ich es hin den größtern Wert für jedes Teilarray heraus zu finden wenn ich nicht weiß wie viele es überhaupt gibt?

Du weißt doch, wie viele es sind: b.length

 

[kneitzel]

Wir wollen nicht die Werte des Arrays aufaddieren. Es geht nur um die Größe des Arrays. Also so:

public static int getElementCountOfArrayWithIgnoredElements(int array[], int ignoreCount) {
    if (array.length <= ignoreCount) return 0;
    
    return array.length - ignoreCount;
}

Kannst Du nun eine Methode schreiben, die die Anzahl der Elemente in einem zweidimensionalen Array (Einem Array von Arrays) ermittelt?

public static int getElementCountOfArraysWithIgnoredElements(int array[][], int ignoreCountPerArray) {
}

Tipp 1: Nutz dazu die obere Methode.
Tipp 2: Jede Methode ist sehr klein. Es werden in der Regel nie mehr als 5 Befehle zu erwarten sein ...

 

[mihe7]

Wäre meine Lösung.

Hast Du die einmal ausprobiert? Hat sich erledigt (s. vorherigen Kommentar von @JustNobody )

 

[tfausw]

Hast Du die einmal ausprobiert? Hat sich erledigt (s. vorherigen Kommentar von @JustNobody )

Ja, bei mir kam ja auch dasselbe raus nur war deutlich länger, deswegen wundert mich das gerade

 

[mihe7]

bei mir kam ja auch dasselbe raus

Nein, bei Dir kam der Wert des letzten Elements im Array abzgl. ignoreCount raus - oder 0, falls ignoreCount die Array-Länge übersteigt. D. h. bei {1,2,3} kommt für ignoreCount==1 tatsächlich 2 raus, bei {1,2,4} dagegen 3.

 

[tfausw]

Nein, bei Dir kam der Wert des letzten Elements im Array abzgl. ignoreCount raus - oder 0, falls ignoreCount die Array-Länge übersteigt. D. h. bei {1,2,3} kommt für ignoreCount==1 tatsächlich 2 raus, bei {1,2,4} dagegen 3.

Tatsache, sorry.

 

[mihe7]

Tatsache, sorry.

Wichtig ist, dass Du (Deinen) Code verstehst, also nachvollziehen kannst. Das ist mit ein Grund, warum man das in kleinere Methoden aufteilt. Nachvollziehen kannst Du das gedanklich oder wirklich auf Papier. Mit Übung wird es leichter. Bei Schleifen wirklich jede Iteration einzeln durchgehen.

Zurück zum Thema: wo bleibt die Methode aus #159?

 

[tfausw]

Möchte schon fast gar nichts falsches mehr sagen .

public static int count2dPlusRemove(int array[][], int ignoreCountPerArray) {
       
        int result = 0;
        for (int i = 0; i < array.length; i++) {
        result += array[i].length - ignoreCountPerArray;
           
            }
        return result;
    }

 

[kneitzel]

Möchte schon fast gar nichts falsches mehr sagen .

Da musst Du Dir keine Sorgen machen. Nur eben sieh es uns nach, falls mal etwas Ungeduld sichtbar sein sollte. An Anfang ist Programmieren nicht einfach nur eben fällt es uns hier im Forum teilweise schwer, den richtigen Ansatz zu finden.

public static int count2dPlusRemove(int array[][], int ignoreCountPerArray) {
     
        int result = 0;
        for (int i = 0; i < array.length; i++) {
        result += array[i].length - ignoreCountPerArray;
            }
        return result;
    }

Ja, sehr schön. Aber nicht die andere Methode verwendet. Dadurch fehlt der Check, ob denn genug Element im Array sind.

public static int count2dPlusRemove(int array[][], int ignoreCountPerArray) {
  int result = 0;
  for (int i = 0; i < array.length; i++) {
    result += getElementCountOfArrayWithIgnoredElements(array[i].length, ignoreCountPerArray);
  }
  return result;
}

So sähe es mit der Methode aus.

Nun brauchen wir als nächstes eine Method, die das größte Element ans Ende packt. Wenn Du bereits ein Sortieralgorithmus hast, dann nimm einfach den. (Der macht zwar zuviel, und hat ein schlechteres Laufverhalten, aber das kann man ggf ignorieren.)

Und wenn Du das hast, dann bauchen wir noch ein copyArray(source, sourceStart, sourceEnd, target, targetStart)
mit source und target den Arrays und das andere sind die indices - also welcher Bereich vom source kopiert werden soll und wohin im target es gehen soll.

 

[tfausw]

Ja, sehr schön. Aber nicht die andere Methode verwendet. Dadurch fehlt der Check, ob denn genug Element im Array sind.

public static int count2dPlusRemove(int array[][], int ignoreCountPerArray) {
  int result = 0;
  for (int i = 0; i < array.length; i++) {
    [B][U]result += getElementCountOfArrayWithIgnoredElements(array[i].length, ignoreCountPerArray);[/U][/B]
  }
  return result;
}

War zu blöd das so richtig zu schreiben, daran gedacht hatte ich, nur bisschen an der Sache vorbei gedacht.

Nun brauchen wir als nächstes eine Method, die das größte Element ans Ende packt. Wenn Du bereits ein Sortieralgorithmus hast, dann nimm einfach den. (Der macht zwar zuviel, und hat ein schlechteres Laufverhalten, aber das kann man ggf ignorieren.)

        int counter = 0;
        for (int[] r : array) {
            Arrays.sort(r);
            for (int i = 0; i < array.length - 1; i++) {
                result[counter] = r[i];   
                counter++;
            }
        }

Das Array wird sortiert und das letzte Element wird nicht übernommen. (Falls richtig )

Da musst Du Dir keine Sorgen machen. Nur eben sieh es uns nach, falls mal etwas Ungeduld sichtbar sein sollte. An Anfang ist Programmieren nicht einfach nur eben fällt es uns hier im Forum teilweise schwer, den richtigen Ansatz zu finden.

Dafür nochmal wirklich herzlichsten Dank an euch, dass ihr Anfängern helft!

 

[kneitzel]

Ja, ist ok. Der Code scheint auf den ersten Blick das zu machen, was verlangt ist. Nur eben ging es mir auch etwas um die Unterteilung, damit man dann entsprechend viele kleine Methoden hat, die alle direkt selbsterklärend sind.

Aber wenn wir damit einen Abschluss gefunden haben sollten, dann soll es auch ok sein ... müssen ja nicht 300 voll kriegen

 

[tfausw]

Tatsächlich war es das leider glaube ich noch nicht ..

Ich habe immer noch zwei Fehler:
1. (falls array null oder leer)

for (int i = 0; i < array.length; i++) {
            if (array == null || array.length == 0) {
                return new int[] {};
            }
        }

/* Ausgabe: Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
/at Functionality.flatternAndSortWithoutBiggest(Functionality.java:29) Zeile 29 = result[counter] = r[i];
/    at Functionality.main(Functionality.java:54)
*/

2. Rechenfehler, Ausgabe [8, 7, 2, 2, 1, 0, 0, 0, 0, -4], bei Eingabe {1,11,3,2},{5,-4,6,2,4,2},{8,9,7}
(nachträglich wird absteigend sortiert)

        int counter2 = 0;
        for (int i = 0; i < array.length; i++) {
            counter2 += array[i].length;
        }
      
        int[] result = new int [counter2 - array.length];

        int counter = 0;
        for (int[] r : array) {
            Arrays.sort(r);
            for (int i = 0; i < array.length - 1; i++) {
            result[counter] = r[i]; 
            counter++;
            }
        }

 

[jono]

public class Test {
    public static int[] doit() {
           int[] eindim = new int[9];
           int[][] zweidim = {
                   new int[] {1,2,3},
                   new int[] {4,5,6},
                   new int[] {7,8,9} };

           // Kopiere alle Teilarrays aus zweidim nach eindim
           int counter = 0;
           for (int i = 0; i < zweidim.length; i++) {
               for (int j = 0; j < zweidim[i].length; j++) {                
                   eindim[counter] = zweidim[i][j];
                   counter++;
               }
           }
                       
           // Sortiere eindim
           boolean swapped;
           do {
               swapped = false;
               for(int i = 1; i<eindim.length;i++) {
                   if(eindim[i]>eindim[i-1]) {
                       int swap = eindim[i-1];
                       eindim[i-1] = eindim[i];
                       eindim[i] = swap;
                       swapped = true;
                   }            
                }                           
           } while(swapped);

           // Fertig
           return eindim;
    }

    public static void main(String[] args) {
        System.out.println(Arrays.toString(doit()));
    }
}

 

[jono]

Wie bestimme ich denn jetzt hier jedes Maximum der Teilarrays aus "zweidim"? Diese muss ich dann auch löschen. Mit den vorherigen Beiträgen war es mir nicht ganz schlüssig

 

[kneitzel]

@tfausw

Den ersten Part hatten wir doch mit den Methoden etwas abgefackelt dachte ich.

Der Code macht so auch keinen Sinn: In der äußeren for Schleife greifst du auf array.length zu und dann prüfst Du, ob array null ist? Wäre array null, dann hättest Du bei array.length eine NPE bekommen.
Wäre array.length 0, dann wärst Du in die for schleife nicht rein gekommen, denn i startet bei 0 und läuft, so lange es kleiner array.length ist. 0 ist nicht kleiner 0, also würde er nie in die Schleife gehen.

 

[kneitzel]

Wie bestimme ich denn jetzt hier jedes Maximum der Teilarrays aus "zweidim"? Diese muss ich dann auch löschen. Mit den vorherigen Beiträgen war es mir nicht ganz schlüssig

Also bisher war die Kernidee, dass die Maxima nicht erst mit kopiert wurden. Dazu diente die Idee, das Maximum ans Ende zu setzen um dann das letzte Element in jedem Teil-Array von Anfang an nicht mit zu kopieren.

Ansonsten kannst Du auch gerne einen anderen Weg gehen, in dem Du dann nach dem aufbau des eindimensionalen Arrays hin gehst und dann
für jedes Teil-Array das Maximum ermitteln um dann im Ergebnis-Array ein Vorkommen vom ermittelten Maximum zu löschen.

 

[jono]

Die erste Idee kann ich halt nicht umsetzen weil die Arrayelemente in beliebiger Reihenfolge eingegeben werden können sollen, also das Maximum nicht ans Ende gebunden sein darf.

int max = Integer.MIN_VALUE;
for(int i: zweidim) if(max<i) max=i;

Ist das korrekt oder ist die Ermittlung so falsch weil mir wird max< i und das nach dem "=" rot angestrichen

 

[kneitzel]

Nur weil eine Eingabe in beliebiger Reihenfolge erfolgen kann, bedeutet dies doch nicht, dass man es nicht ändern darf, oder?

Und zweidim ist sozusagen ein Array of Arrays. i ist damit nicht ein int sondern ein int[].
Hinzu kommt, dass Du ja nicht das Maximum auf zweidim haben willst sondern jeweils von jedem Teil-Array.

Ihr macht euch euer Leben selbst unnötig schwer, in dem ihr zu viel auf einmal versucht... und dabei dann Code schreibt, der unleserlich und schwer zu verstehen ist.

Und wenn etwas rot angestrichen wird: Mal mit der Maus drüber gehen und schauen, was die IDE dann als Meldung ausspuckt. Zur Not einmal die Übersetzung starten!

 

[jono]

Das klingt so abstrakt, ja ist ein int[] das stimmt, aber die teilarrays sind ja "zweidim" zugehörig und wie spreche ich denn die Teilarrays an? Und wie setze ich die Maxima an die letzte Stelle der Teilarrays im Code

 

[kneitzel]

Also das wurde mehrfach in den Threads behandelt.

Ich habe jetzt einfach einmal einen kurzen Code geschrieben, der die Idee: "Abwandeln des QuickSort Algorithmus" aufgreift.

import java.util.Arrays;
import java.util.logging.Logger;

public class ArrayMerge {
    private final static Logger log = Logger.getLogger(ArrayMerge.class.getName());

    public static int[] quicksort(final int[] source) {
        return sort(source, 0, source.length-1);
    }

    public static int[] sort(final int[] source, final int start, final int end) {
        log.info("sort: " + start + " - " + end);
        int[] result;

        if (end - start > 0) {
            int[] first = sort(source, start, start + (end-start)/2);
            int[] second = sort(source, start + (end-start)/2 + 1, end);
            result = merge(first, second);
        } else {
            result = new int[] { source[start] } ;
        }
        log.info("sort(" + Arrays.toString(source) + ", " + start + ", " + end + ") = " + Arrays.toString(result));
        return result;
    }

    public static int[] merge(final int[] first, final int[] second) {
        return merge(first, first.length, second, second.length);
    }

    public static int[] merge(final int[] first, final int lengthFirst, final int[] second, final int lengthSecond) {
        // Normalen QuickSort Algorithmus könnte man durch ersetzen von lengthFirst und lengthSecond durch
        // first.length und second.length bekommen.
        int[] result = new int[lengthFirst + lengthSecond];

        int firstIndex = 0;
        int secondIndex = 0;
        int resultIndex = 0;
        while (resultIndex < result.length) {
            if (firstIndex < lengthFirst && secondIndex < lengthSecond) {
                // We take minimum from first and second
                if (first[firstIndex] < second[secondIndex]) {
                    result[resultIndex] = first[firstIndex];
                    firstIndex++;
                } else {
                    result[resultIndex] = second[secondIndex];
                    secondIndex++;
                }
            } else if (firstIndex < lengthFirst) {
                // We take element from first
                result[resultIndex] = first[firstIndex];
                firstIndex++;
            } else {
                // We take element from second
                result[resultIndex] = second[secondIndex];
                secondIndex++;
            }
            resultIndex++;
        }

        log.info("Merged: " + Arrays.toString(first) + " + " + Arrays.toString(second) + " = " + Arrays.toString(result));
        return result;
    }

    public static void main (String[] args) {

        // testing the QuickSort
        int[] array = { 17, 32, 3, 45, 1, 7 };
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(ArrayMerge.quicksort(array)));

        // Now merging the Arrays with ignoring of the highest Element.
        int[][] twodimarray = { { 21, 14, 7 },
                { 8, 32, 24, 16 },
                { 9, 18, 27} };

        int[] result = new int[0];

        for(int[] subArray: twodimarray) {
            if (subArray.length > 1)
                result = merge(result, result.length, quicksort(subArray), subArray.length - 1);
        }

        System.out.println(Arrays.toString(result));
    }
}

In dem Code findet man in erster Linie den QuickSort. Lediglich das merge wurde für die Anforderungen angepasst, so dass die zu behandelnde Größe mit angegeben werden kann. Die Parameter firstLength und secondLength kann man aber entfernen und dann im code duch die .length Angaben ersetzen um dann das altbekannte merge zu haben.

Und dann ist der gewünschte Code nur noch nach und nach ein Merge der Listen mit dem Zwischenergebnis.
Sollte ein Teilarray nicht mehr wie ein Element haben, so ist kein Merge notwendig.

Also wenn Ihr QuickSort hattet, eine relativ einfache Anpassung...

Edit: Habe sogar einige log Aufrufe eingebaut zum einfachen nachvollziehen der Sortierung. Falls es da noch Verständnisprobleme geben sollte.

 

[jono]

Ich darf laut Aufgabenstellung nur BubbleSort verwenden

 

[kneitzel]

Wie Du sortierst ist doch egal. Dann ersetz den quicksort Aufruf durch bubblesort.
Der wichtige Punkt ist lediglich der merge und das ist schlicht und einfach nur ein merge von zwei sortierten Arrays in ein sortiertes Zielarray. Und das war ja genau die Aufgabe, was zu schreiben war.

 

[jono]

import java.util.Arrays;


public class Functionality {

	public static void main(String[] args) {
		
	System.out.println(Arrays.toString(flatternAndSortWithoutBiggest(new int[][] {{1,2,3},{4,5,6},{7,8,9}})));
	
	}
	
	public static int[] flatternAndSortWithoutBiggest(int[][] array) {
		
		if (array == null || array.length == 0)
        throw new IllegalArgumentException ("Array null oder leer!");
		
		   int[] eindim = new int[9]; 
	       int[][] zweidim = { 
	               new int[] {1,2,3},  
	               new int[] {4,5,6}, 
	               new int[] {7,8,9}}; 

	       int counter = 0; 
	       for (int i = 0; i < zweidim.length; i++) { 
	           for (int j = 0; j < zweidim[i].length; j++) {
	        	   
	        	   eindim[counter] = zweidim[i][j]; 
	               counter++; 
	    	  
	       }
	       }
	       
	         boolean swapped;
	           do {
	           swapped = false;
	           for(int i = 1; i<eindim.length;i++) {
	           if(eindim[i]>eindim[i-1]) {
	           int swap = eindim[i-1];
	           eindim[i-1] = eindim[i];
	           eindim[i] = swap;
	           swapped = true;
	                          }
	           
	                 }
	           
	           
	             }while(swapped);
	           
	           
	           int max = Integer.MIN_VALUE;
	           for(int[] i : ) if(max<i) max=i;
	         
	           
	           return eindim;
    	 
	}    
           
         
}

Ich würde mich gerne an dem Code orientieren es ist schon alles fertig nur dass die Maxima aus den Teilarrays des "zweidim" noch ausgelassen werden müssen

 

[jono]

Ja stimmt , nur dein Code sieht so kompliziert aus ^^

 

[jono]

Ich kann jetzt nicht wirklich herausfiltern wie ich deinen Code bzw welchen Teil deines Codes ich jetzt sinnvoll an meinen anpassen kann das ist mein großes Problem

 

[kneitzel]

Die Idee ist mehrfach genannt worden und wurde sogar groß und breit erläutert: Du kannst die Teil-Arrays durchgehen und das Maximum an die letzte Stelle schreiben. Dann musst Du nur noch beim Kopieren jeweils die letzte Stelle auslassen....

Und genau das ist auch die Idee, die ich verfolgt habe ...

 

[Snaer]

Ja stimmt , nur dein Code sieht so kompliziert aus ^^

Klingt vielleicht dumm, aber ich muss mich anschließen. Leider fällt es mir schwer einen schnellen Überblick zu finden.

 

[jono]

Ich kann mit Deinen Hilfen von den vorherigen Seiten zu dem Problem "Maximum ermitteln und auslassen" auch nicht wirklich viel anfangen weil da Sachen drin stehen die ich z.B. nicht kenne und ich dementsprechend nicht weiß diese einzufügen.
Ich wäre Dir sehr dankbar wenn du dich nochmal genau auf meinen Code beziehst um sozusagen individueller darauf einzugehen
Wie ermittelt man denn das Maximum von den Teilarrays von "zweidim" , bei Google kann ich da nicht mal etwas maßschneidern für mich sitze ja die ganze Zeit am Laptop überlege und suche nach Lösungen. Also wie sortiere ich Teilarrays? und wie ermittle ich das Maximum von den Teilarrays ? sortieren an sich ist nicht das Problem nur das sortieren bei meinen Teilarrays. Das ist mein Problem .

 

[mihe7]

3 2 1
5 6 4
8 7 9

Für jede Zeile wird jetzt die Position des Maximums ermittelt und mit dem letzten Element getauscht:

3 2 1 -> Maximum an Index 0

Vertausche im Array den Wert an Index 0 mit dem Wert an Index 2 (letzter Index im Array)

1 2 3

5 6 4 -> Maximum an Index 1

Vertausche im Array den Wert an Index 1 mit dem Wert an Index 2 (letzter Index im Array)

5 4 6

8 7 9 -> Maximum an Index 2

Vertausche im Array den Wert an Index 2 mit dem Wert an Index 2 (letzter Index im Array)

8 7 9

Ergebnis

1 2 3
5 4 6
8 7 9

Jetzt kopiert man jedes dieser Arrays in 1D-Array, lässt aber jeweils das letzte Element aus:

1 2 3 --> 1 2
5 4 6 --> 1 2 5 4
8 7 9 --> 1 2 5 4 8 7

 

[Snaer]

3 2 1
5 6 4
8 7 9

Für jede Zeile wird jetzt die Position des Maximums ermittelt und mit dem letzten Element getauscht:

3 2 1 -> Maximum an Index 0

Vertausche im Array den Wert an Index 0 mit dem Wert an Index 2 (letzter Index im Array)

1 2 3

5 6 4 -> Maximum an Index 1

Vertausche im Array den Wert an Index 1 mit dem Wert an Index 2 (letzter Index im Array)

5 4 6

8 7 9 -> Maximum an Index 2

Vertausche im Array den Wert an Index 2 mit dem Wert an Index 2 (letzter Index im Array)

8 7 9

Ergebnis

1 2 3
5 4 6
8 7 9

Jetzt kopiert man jedes dieser Arrays in 1D-Array, lässt aber jeweils das letzte Element aus:

1 2 3 --> 1 2
5 4 6 --> 1 2 5 4
8 7 9 --> 1 2 5 4 8 7

Das Grund Prinzip ist schlüssig, aber ich tue mich schwer damit es in einem mehrdimensionalen Array umsetzen. Mein Ansatz bislang sieht so aus allerdings funktioniert es damit leider noch nicht.

int tmp = 0;
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                tmp = b[i][0];
                if (b[i][j] > tmp) {
                    tmp = b[i][j];
                    b[i][j] = b[i][b[i].length - 1];
                    b[i][b[i].length - 1] = tmp;
                }
            }
        }

 

[jono]

Okay sehr gut aufgegriffen, aber wie ermittelt man denn jetzt das Maximum davon ?

 

[jono]

Der erste Schritt ist für mich das größte Problem

 

[Snaer]

Mein Problem ist hauptsächlich die Umsetzung wenn man die Werte der einzelnen Arrays nicht kennt.
Wenn man sich die Werte selbst vorgibt bekomme ich es an sich hin indem ich die einzelne Arrays durch gehe, aber das funktioniert bislang nur soweit ich die Arrays auch klar angebe also b[0] etc. mit meiner Schleife bei der ich versuche unbekannte Arrays umzusetzen klappt es allerdings leider nicht

 

[mihe7]

Das Grund Prinzip ist schlüssig, aber ich tue mich schwer damit es in einem mehrdimensionalen Array umsetzen.

Das ist das, was ich ziemlich am Anfang des Threads schon einmal zu erklären versucht habe (auch im Zusammenhang mit dem Maximum). Ihr müsst anfangen, die Dinge besser voneinander zu isolieren. Das funktioniert genauso wie mit einem 1D-Array, nur dass nochmal eine Schleife außenrum ist:

for (int i = 0; i < array.length; i++) {
    int[] subArray = array[i];
    if (subArray.length > 0) {
        // ermittle Index ix des größten Elements in subArray
        // und danach: vertausche ix und subArray.length-1 in subArray.
    }
}

Wie ermittelt man nun den Index des größten Elements in einem Array?

int ix = 0;
int max = subArray[ix];
for (int k = ix + 1 ; k < subArray.length; k++) {
    if (subArray[k] > max) {
        max = subArray[k];
        ix = k;
    }
}

Danach steht in ix der Index des größten Elements. Wie vertauscht man nun das Element ix und das letzte Element in subArray?

int last = subArray.length - 1;
int tmp = subArray[ix];
subArray[ix] = subArray[last];
subArray[last] = tmp;

So, alles zusammen:

for (int i = 0; i < array.length; i++) {
    int[] subArray = array[i];
    if (subArray.length > 0) {
        // ermittle Index ix des größten Elements in subArray
        int ix = 0;
        int max = subArray[ix];
        for (int k = ix + 1 ; k < subArray.length; k++) {
            if (subArray[k] > max) {
                max = subArray[k];
                ix = k;
            }
        }

        // und danach: vertausche ix und subArray.length-1 in subArray.
        int last = subArray.length - 1;
        int tmp = subArray[ix];
        subArray[ix] = subArray[last];
        subArray[last] = tmp;
    }
}

Das ist aber ziemlich hässlich, daher lagert man die Dinge in Methoden aus:
Schöner:

for (int i = 0; i < array.length; i++) {
    int[] subArray = array[i];
    if (subArray.length > 0) {
        int ix = indexOfMax(subArray);
        swap(ix, subArray.length-1);
    }
}

Die Methoden sehen genauso wie der Code aus, den sie ersetzt haben, nur dass die Parameter ggf. anders benannt werden und am Ende ein return folgt.

 

[Snaer]

Tut mir Leid für die dumme Frage, aber verstehe ich es richtig das sich dieser Code jetzt auf ein 1D Array bezieht? Weil du ja angesprochen hast, dass man eine weitere Schleife außen rum benötigt oder ist array das 2 Dimensionale array?

 

[mihe7]

Das array ist das 2D-Array, subArray ist das "aktuelle" 1D-Array (aus array) innerhalb der "Schleife außenrum".

 

[Snaer]

Könntest du mir es dann vielleicht ein wenig erläutern?
Du beginnst ja mit der For Schleife in der i inkrementiert wird. Allerdings nur solange i < array.length ist.
Dabei verstehe ich jetzt folgendes nicht ganz: array.length gibt ja bei einem 2D Array die Anzahl der Teil Arrays an wenn ich jetzt nicht völlig falsch liege.
Mit dem Code int [] subArray = array durchläuft man dann doch nicht vollständig jedes mögliche Array oder? Oder ist das quasi der Schritt in dem du alle möglichen Werte des 2D Arrays in das 1D transferierst?

 

[mihe7]

Du beginnst ja mit der For Schleife in der i inkrementiert wird. Allerdings nur solange i < array.length ist.
Dabei verstehe ich jetzt folgendes nicht ganz: array.length gibt ja bei einem 2D Array die Anzahl der Teil Arrays an wenn ich jetzt nicht völlig falsch liege.

array.length gibt an, wie viele Elemente array aufnehmen kann (sprich: die Größe von array).

In diesem Fall handelt es sich bei den Elementen zufälligerweise um Arrays. Es spielt also gar keine Rolle, was in dem Array steckt: {a,b,c} hat drei Elemente, egal ob a nun ein int oder ein Array ist.

Mit dem Code int [] subArray = array[i] durchläuft man dann doch nicht vollständig jedes mögliche Array oder?

Nein, damit hole ich mir einfach das i-te Element aus array - bei dem es sich ja wieder um ein Array handelt. Das subArray durchlaufen wird erst in der zweiten Schleife.

 

[Snaer]

Dabei verstehe ich dann nicht ganz was die erste For Schleife genau bewirkt.
Soweit ich es bislang verstanden habe werden die Indexe bei mehrdimensionalen Arrays quasi so angesprochen b[0][0] gibt mir dann den Wert des ersten Teilarrays am Index 0 aus.
Müsste ich dementsprechend nicht auch bei array dann zwei Klammern jeweils anpassen?

Und damit sind die Werte ja noch nicht übertragen richtig?
Da stellt sich mir nun das weitere Problem, dass das eindimensionale Array außerhalb der for Schleife nicht deklariert ist.

 

[mihe7]

Dabei verstehe ich dann nicht ganz was die erste For Schleife genau bewirkt.

Also, Du hast ein "äußeres Array", das mehrere "innere Arrays" enthält. Ähnlich einer Tabelle: die kann man als Array von Zeilen auffassen und jede Zeile als Array von Spalten.

Mit der äußeren for-Schleife durchlaufe ich nun die Indizes des äußeren Arrays (in der Tabelle: sozusagen die Zeilennummern) und hole mir mit array[i] das i-te innere Array (die i-te Zeile).

Soweit ich es bislang verstanden habe werden die Indexe bei mehrdimensionalen Arrays quasi so angesprochen b[0][0] gibt mir dann den Wert des ersten Teilarrays am Index 0 aus.

Das kann man machen, weil b[0] ein Array liefert

int[] subArray = b[0];
int wert = subArray[4];
// ist analog zu
int wert = (b[0])[4];
// also
int wert = b[0][4];

Müsste ich dementsprechend nicht auch bei array dann zwei Klammern jeweils anpassen?

Nein, weil es in Java keine echten mehrdimensionalen Arrays gibt: es sind Arrays von Arrays.

Und damit sind die Werte ja noch nicht übertragen richtig?

Nein. Der Code verschiebt lediglich das Maximum eines jeden Subarrays ans Ende.

Da stellt sich mir nun das weitere Problem, dass das eindimensionale Array außerhalb der for Schleife nicht deklariert ist.

Das macht ja nichts, Du kannst ja über array auf die einzelnen Arrays zugreifen.

 

[Snaer]

Das macht ja nichts, Du kannst ja über array auf die einzelnen Arrays zugreifen.

Sind die Werte dadurch denn dann in array sortiert ? Weil du hattest in den Code doch nur Werte zu subArray zugewiesen und array nur für die For Schleife benutzt.
Und wie bringe ich diese Werte jetzt ins 1D Array ? Mein Ansatz dabei sieht so aus

int count = 0;
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length - 1; j++) {
                a[count] = b[i][j];
                count++;
            }
        }
        boolean swapped;
        do {
            swapped = false;
            for (int i = 1; i < a.length; i++) {
                if (a[i] > a[i - 1]) {
                    int swap = a[i - 1];
                    a[i - 1] = a[i];
                    a[i] = swap;
                    swapped = true;
                }
            }
        } while (swapped);
        System.out.println(Arrays.toString(a));

Problem dabei ist mit dem Ausgangsarray
int[][] b = { new int[] { 1, 2, 3, 4 }, new int[] { 4, 3, 2, 1 }, new int[] { 0, 7, 8, 4, 3 },
new int[] { -13, 4 } };
bekomme ich jedoch dabei die Ausgabe [8, 7, 4, 3, 3, 2, 2, 1, 1, 0, 0, 0, 0, 0, -13]
Woher dabei die ganzen 0 kommen ist mir ehrlich gesagt ein Rätsel.
Ich hatte versucht die letzte Stelle dadurch zu ignorieren indem ich das b.length -1 durch eine -2 ersetzte , das führt allerdings nur dazu das die -13 durch eine weitere 0 ersetzt wird.

 

[mihe7]

Sind die Werte dadurch denn dann in array sortiert ?

Nein, das ist auch unnötig, da das Ausgabearray sowieso sortiert werden muss.

Und wie bringe ich diese Werte jetzt ins 1D Array ? Mein Ansatz dabei sieht so aus

Ja, der passt.

Woher dabei die ganzen 0 kommen ist mir ehrlich gesagt ein Rätsel.

Du hast die Größe für a noch nicht richtig berechnet. Wenn Du ein Array der Größe 15 erzeugst, sind erstmal alle Werte im Array 0. Wenn Du jetzt 10 Werte in das Array kopierst, stehen am Ende 5 Nullen. Wenn Du jetzt noch absteigend sortierst, stehen die negativen Werte rechts von den 0en.

 

[Snaer]

Ja, der passt.

Aber mit dem Ansatz funktioniert es ja noch nicht das die letzte Stelle des Arrays ignoriert wird.
Ich dachte mir das ich durch b.length-2 quasi die letzte Stelle dann ignorieren müsste aber dadurch verschwindet dann jedoch aufeinmal die -13 aus dem Array.

Du hast die Größe für a noch nicht richtig berechnet. Wenn Du ein Array der Größe 15 erzeugst, sind erstmal alle Werte im Array 0. Wenn Du jetzt 10 Werte in das Array kopierst, stehen am Ende 5 Nullen. Wenn Du jetzt noch absteigend sortierst, stehen die negativen Werte rechts von den 0en.

Gibts dann einen anderen Weg damit ich quasi keine leeren Stellen bekomme?
Ich hab die Länge meines ein dimensionalen Array so bestimmt :

int n =0;
int []a;
for (int i = 0; i < b.length; i++){
n+=b[i].length;
}
a= new int [n];