Array Sortieren mit boolean?

pureGewalt

Mitglied
Servus Leute,

ich habe die Aufgabe von einem eingelesenen Array diesen aufsteigend zu sortieren also bsp: [1,3,2] soll zu [1,2,3] werden. Jedoch fehlt mir hier der ansatz wie ich sowas sortieren kann. Meine überlegung war bis jetzt :

Code:
static boolean sortiereArray(int a[]){ //Parameter übergabe des Arrays von der einzulesenden Funktion
    for(int i = 0; i < a.length; i++){
        for(int j = i; j < length; j++){
            if(a[i] > a[j]){
            a[j] = a[i];
            }
        }
    }
    return a;
}

Kommt aber immer nicht das richtig raus und ich weiß leider nicht weiter, vor allem ist wichtig das ich es mit dem Datentyp boolean löse und ich weiß nicht wie.

Freue mich über jede Hilfe.
Grüße :)
 
K

kneitzel

Gast
Wenn Du Werte tauschen willst, dann musst Du einen Wert erst zwischenspeichern, dann kannst Du den gespeicherten Wert überschreiben um dann den gespeicherten Wert in das zweite Feld zu schreiben.

Java:
// Jetzt mal einfach a und b als Variablen:
int a = 1;
int b = 2;

// a und b tauschen:
// Falsch ist:
a = b; // Hier wäre der Wert, der in a gespeichert war, weg!

// richtig:
int temp = a; // Wir merken und den Inhalt von a.
a = b; // Wir überschreiben a - haben es ja gemerkt.
b = temp; // Wir überschreiben b, der original Wert ist ja jetzt in a.
 

pureGewalt

Mitglied
Wenn Du Werte tauschen willst, dann musst Du einen Wert erst zwischenspeichern, dann kannst Du den gespeicherten Wert überschreiben um dann den gespeicherten Wert in das zweite Feld zu schreiben.

Java:
// Jetzt mal einfach a und b als Variablen:
int a = 1;
int b = 2;

// a und b tauschen:
// Falsch ist:
a = b; // Hier wäre der Wert, der in a gespeichert war, weg!

// richtig:
int temp = a; // Wir merken und den Inhalt von a.
a = b; // Wir überschreiben a - haben es ja gemerkt.
b = temp; // Wir überschreiben b, der original Wert ist ja jetzt in a.

Danke habe es jetzt mit einem ZwischenSpeichern hinbekommen! Zumindest das, dass Array sortiert wird. Jetzt habe ich leider ein anderes Problem, wie kann ich das mit boolean lösen? Weil jedes mal wenn ich jetzt die eingabe mache:
Beispiel:
Frage nach Größe Array = 5
dann gebe ich ein 1,3,2,4,5
Vorher wurde mir der "durcheinander Array" angezeigt jetzt seitdem ich diese Methode drin habe
wird jedes mal direkt sortiert und ich verstehe echt nicht warum.

Habe gemerkt sobald ich die "sortiere zwueisung wegmache" funktioniert was wieder ganz normal.
Code:
    //Methoden Aufrufe
            int [] eingaben = arrayEinlesen(n,in);
            int maximum = maxImArray(eingaben);
            int[] sortieren = sortiereArray(eingaben);

Einlesen Methode:
Code:
public static int[] arrayEinlesen(int n, Scanner in) {
        
        //Deklaration
        int[] a = new int[n];
        int i = 0;
        int eingabe = 0;
        
        while(i < n) {
            eingabe = in.nextInt();
            a[i] = eingabe;
            i++;   
        }
            //Rückgabewert des Arrays a
            return a;

Meine Ausgaben mache ich jeweils mit der to.String Methode.

Liebe Grüße und danke für die Hilfe!
 

pureGewalt

Mitglied
Sorry bin noch so neu in dem Gebiet fällt mir manchmal noch echt schwer meine Probleme zu prezisieren.

Ich habe einmal diese Methode:
Code:
public static int[] arrayEinlesen(int n, Scanner in) {
        
        //Deklaration
        int[] a = new int[n];
        int i = 0;
        int eingabe = 0;
        
        while(i < n) {
            eingabe = in.nextInt();
            a[i] = eingabe;
            i++;   
        }
            //Rückgabewert des Arrays a
            return a;

... womit ich das Array einlese in der main

dort rufe ich sie dann auf und gebe Sie aus. Alles nachfolge ist in der main methode:
Code:
int [] eingaben = arrayEinlesen(n,in);
greife auf das einlesen zu und gebe es hiermit dann aus:
Code:
System.out.println(Arrays.toString (eingaben));

Jetzt kann ich ja beliebige Arrays einlesen lassen. Doch sollte ich laut Aufgabenstellung nun noch eine Methode erstellen um die diese Sortiert mit boolean. Aufsteigend und absteigend.

Jetzt habe ich diese Methode implementiert für aufsteigend :
Code:
public static int[] sortiereArray(int a[]) {
        for(int i = 0; i < a.length; i++) {
            for(int j = i; j < a.length; j++) {
                if(a[i] > a[j]) {
                    int zwischenSpeicher = a[i];
                    a[i] = a[j];
                    a[j] = zwischenSpeicher;
                }
            }
        }
        return a;

... um zuerst mal aufsteigend zu machen aber ohne boolean weil ich einfach nicht weiß welche möglichkeit es gäbe einen Array zu sortieren mit dem Datentyp boolean im bezug auf aufsteigend anzeigen lassen, oder absteigend je nach dem was der Nutzer möchte.

Dann gebe ich in der main diese Methode aus um mein vorheriges Array zu sortieren´:
Code:
int[] sortieren = sortiereArray(eingaben);

System.out.println(Arrays.toString(sortieren));

Jetzt ist mein Problem das, jetzt auch immer der eingelesene Array direkt sortiert wird.
Meine Ausgabe:
Hallo, bitte geben Sie die größe Ihres Arrays ein:
5
Geben Sie nun nach und nach Zahlen zum füllen ein:
1
3
2
4
5
Ihr eingebener Array
[1, 2, 3, 4, 5] -> hier müsste doch eigentlich der Array stehen wie es eingelesen wurde?
[1, 2, 3, 4, 5] -> und hier der Sortierte

Jetzt sind immer beide direkt Sortiert und ich verstehe nicht warum :/
 
K

kneitzel

Gast
Also ein Array wird als Referenz übergeben. Änderungen an einem übergebenen Array sind somit nicht nur lokal sondern überall vorhanden.

Also musst du das Array auch nicht mehr zurück geben, da das Original Array sortiert ist.
Wenn du eine Kopie sortieren willst, dann musst du erst das Array clonen um dann den Clon zu sortieren und zurück zu geben.
 

mihe7

Top Contributor
Und was das boolean betrifft, sollst Du etwas wie

Java:
public static int[] sortiereArray(int a[], boolean aufsteigend) {

schreiben, damit Du beim Sortieren angeben kannst, ob auf- oder absteigend.
 

pureGewalt

Mitglied
Also ein Array wird als Referenz übergeben. Änderungen an einem übergebenen Array sind somit nicht nur lokal sondern überall vorhanden.

Also musst du das Array auch nicht mehr zurück geben, da das Original Array sortiert ist.
Wenn du eine Kopie sortieren willst, dann musst du erst das Array clonen um dann den Clon zu sortieren und zurück zu geben.

Danke für den Hinweis habe das Array kopiert und es läuft jetzt mit dem Aufsteigen in der Methode so wie ich es mir vorstelle.

Code:
int [] originalArray = arrayEinlesen(n,in);
            int [] kopieArray = new int[originalArray.length]; //neues Array alloziren
            for(int i = 0; i < originalArray.length; i++) {
                kopieArray[i] = originalArray[i];
            }

Und was das boolean betrifft, sollst Du etwas wie

Java:
public static int[] sortiereArray(int a[], boolean aufsteigend) {

schreiben, damit Du beim Sortieren angeben kannst, ob auf- oder absteigend.

Danke für deinen Hinweis, ganz genau verstanden habe ich es aber glaub noch nicht. Also ich möchte ja das der Benutzer bei der Sortierung entscheiden kann ob er es auf oder absteigend haben möchte. Ganz einfach gesagt boolean hat ja true oder false, muss ich dann irgendwie zuweisen das aufsteigend -> false und absteigend -> true und dann wird das in der Methode gemacht und der benutzer bekommt das zurück? Muss ich dann auch die syso's in der Methode verpacken wo bspw. gefragt wird "möchten sie auf oder ab.." ? Kann ich überhaupt in einer Methode jeweils abfragen nach auf oder absteigend oder müssen das zwei Methoden werden?

Liebe Grüße und Danke nochmal.
 
K

kneitzel

Gast
Also der Name besagt es ja: Aufsteigend? Ja/Nein
Also wenn aufsteigend true ist, dann soll es aufsteigend sortiert werden und wenn aufsteigend false ist, dann soll es absteigend sortiert werden. Das ist bei zwei Werten durchaus üblich.
Wenn Dir das noch nicht ausreichend ist, dann kannst Du den Parameter noch umbennen a.la. "sortiereAufsteigend" oder so...

Es gibt aber - wie so oft - immer viele Wege, die zum Ziel führen.
Man könnte eine Enum "Sortierfolge" erstellen mit "AUFSTEIGEND" und "ABSTEIGEND" und dann hätte man als Parameter kein boolean mehr sondern die Sortierfolge und man würde übergeben "Sortierfolge.AUFSTEIGEND" bzw. "Sortierfolge.ABSTEIGEND".
 
K

kneitzel

Gast
Also ich möchte ja das der Benutzer bei der Sortierung entscheiden kann ob er es auf oder absteigend haben möchte. Ganz einfach gesagt boolean hat ja true oder false, muss ich dann irgendwie zuweisen das aufsteigend -> false und absteigend -> true und dann wird das in der Methode gemacht und der benutzer bekommt das zurück? Muss ich dann auch die syso's in der Methode verpacken wo bspw. gefragt wird "möchten sie auf oder ab.." ? Kann ich überhaupt in einer Methode jeweils abfragen nach auf oder absteigend oder müssen das zwei Methoden werden?

Liebe Grüße und Danke nochmal.

Und ganz überlesen: Hier geht es erst einmal nur um eine Funktion, die sortiert. Wenn Du willst, dass der Benutzer das angibt, dann musst Du natürlich noch abfragen, wie der Benutzer es sortiert haben will.

Also da, wo Du die Zahlen abfragst kommt dann am Ende: "Wie soll sortiert werden? (Absteigend / Aufsteigend)" oder um die Eingabe kürzer zu machen, kannst Du ja fragen "Soll aufsteigend sortiert werden? (Ja / Nein)" oder so. Das fragst Du dann ab und abhängig von der Eingabe hast Du dann den Parameter für die Funktion.
 

mihe7

Top Contributor
Also ich möchte ja das der Benutzer bei der Sortierung entscheiden kann ob er es auf oder absteigend haben möchte.
OK, ich denk Du hast noch ein Problem damit, die Dinge gedanklich zu trennen. Deine Sortiermethode sortiert - ohne, dass dabei ein Benutzer involviert wäre - ein gegebenes Array und gibt das sortierte Array zurück. Aktuell geschieht das aufsteigend.

Du könntest also Deine Methode umbenennen zu
Code:
public static int[] sortiereAufsteigend(int a[]) {
und eine zusätzliche Methode schreiben:
Code:
public static int[] sortiereAbsteigend(int a[]) {
Die müsste dann natürlich das Array absteigend sortieren.

Das hat alles noch nichts mit dem Benutzer zu tun. Den kannst Du aber fragen: Soll das Array aufsteigend sortiert werden? Dann kannst Du seine Eingabe überprüfen und die betreffende Methode aufrufen, z. B.
Java:
String antwort = scanner.nextLine();
int[] sortiert;
if (antwort.equals("ja")) {
    sortiert = sortiereAufsteigend(eingaben);
} else {
    sortiert = sortiereAbsteigend(eingaben);
}

Würde funktionieren. Aber: Du hast jetzt zwei sortier-Methoden, die fast identisch sind. Daher könnte man auf die Idee kommen, die beiden Methoden zusammenzulegen und über einen Parameter zu entscheiden, ob auf- oder absteigend sortiert werden soll. Dann kommt beispielsweise die im vorherigen Kommentar genannte Methode raus:
Java:
public static int[] sortiereArray(int a[], boolean aufsteigend) {

Der Code, der sich um den Benutzer und den Aufruf der Sortiermethode kümmert, kann dann so aussehen:
Java:
String antwort = scanner.nextLine();
boolean aufsteigendeSortierung = antwort.equals("ja");
sortiert = sortiereArray(eingaben, aufsteigendeSortierung);
 

pureGewalt

Mitglied
OK, ich denk Du hast noch ein Problem damit, die Dinge gedanklich zu trennen. Deine Sortiermethode sortiert - ohne, dass dabei ein Benutzer involviert wäre - ein gegebenes Array und gibt das sortierte Array zurück. Aktuell geschieht das aufsteigend.

Du könntest also Deine Methode umbenennen zu
Code:
public static int[] sortiereAufsteigend(int a[]) {
und eine zusätzliche Methode schreiben:
Code:
public static int[] sortiereAbsteigend(int a[]) {
Die müsste dann natürlich das Array absteigend sortieren.

Das hat alles noch nichts mit dem Benutzer zu tun. Den kannst Du aber fragen: Soll das Array aufsteigend sortiert werden? Dann kannst Du seine Eingabe überprüfen und die betreffende Methode aufrufen, z. B.
Java:
String antwort = scanner.nextLine();
int[] sortiert;
if (antwort.equals("ja")) {
    sortiert = sortiereAufsteigend(eingaben);
} else {
    sortiert = sortiereAbsteigend(eingaben);
}

Würde funktionieren. Aber: Du hast jetzt zwei sortier-Methoden, die fast identisch sind. Daher könnte man auf die Idee kommen, die beiden Methoden zusammenzulegen und über einen Parameter zu entscheiden, ob auf- oder absteigend sortiert werden soll. Dann kommt beispielsweise die im vorherigen Kommentar genannte Methode raus:
Java:
public static int[] sortiereArray(int a[], boolean aufsteigend) {

Der Code, der sich um den Benutzer und den Aufruf der Sortiermethode kümmert, kann dann so aussehen:
Java:
String antwort = scanner.nextLine();
boolean aufsteigendeSortierung = antwort.equals("ja");
sortiert = sortiereArray(eingaben, aufsteigendeSortierung);

VIelen Dank für deine Antwort!
Also das obere habe ich verstanden macht auch Sinn so für mich, Danke! Aber wie Sie bereits geschrieben haben das man diese Methode zusammenlegen könnte und mit dem boolean, da verheddere ich mich noch irgendwie. Das problem ist ich hänge mich total auf das meine Methode als return ein boolean haben muss, bei der Methode oben wäre der rückgabewert ein int. Und gibt es eine alternative zu dem .equals ich glaub das dürfen wir noch nicht beuntzen weil wir soweit noch nicht sind.
Was mir einfällt wäre == operator aber dann wäre es wieder eine magic Number, die ich ebenfalls nicht benutzen darf...
Meine Idee erstmal:
Ich füge dann noch einen paramter "boolean absteigend" hinzu ? Und noch den paramter "antwort"? diesen dann mit if in der Methode verzweigen wenn dann der benutzer z.b. "Ja" eingeben würde? wäre es true und er springt in den ablauf "aufsteigen sortieren" und dann return aufsteigend. Und bei false wäre ja dann egal was er eingibt oder? Und dieses dann einfach return absteigend. Puh dann muss ich aber auch das array a wieder in die beiden jeweils kopieren das ich es an die main liefern kann und als sorties Array ausgeben kann?
 

mihe7

Top Contributor
als return ein boolean haben muss, bei der Methode oben wäre der rückgabewert ein int.
Moment, nicht dass wir jetzt aneinander vorbeireden. Wieso muss der Rückgabewert ein boolean sein und welche Bedeutung soll der Rückgabewert denn haben?

Ich füge dann noch einen paramter "boolean absteigend" hinzu ?
Wenn Du schon einen boolean-Parameter aufsteigend hast, dann brauchst Du keinen zusätzlichen Parameter absteigend, denn "nicht aufsteigend" ist gleichbedeutend mit absteigend :)

Und gibt es eine alternative zu dem .equals ich glaub das dürfen wir noch nicht beuntzen weil wir soweit noch nicht sind.
Was mir einfällt wäre == operator aber dann wäre es wieder eine magic Number, die ich ebenfalls nicht benutzen darf...
Meine Idee erstmal:
Du kannst auch boolean antwort = scanner.nextBoolean(); benutzen. Dann muss der Anwender "true" oder "false" eingeben und Du brauchst keinen Vergleich durchzuführen.

Puh dann muss ich aber auch das array a wieder in die beiden jeweils kopieren das ich es an die main liefern kann und als sorties Array ausgeben kann?
Nein, da kannst Du jetzt den Effekt nutzen, den Du vor dem Kopieren des Arrays hattest. Dazu kommen wir vermutlich später nochmal :)
 

pureGewalt

Mitglied
Moment, nicht dass wir jetzt aneinander vorbeireden. Wieso muss der Rückgabewert ein boolean sein und welche Bedeutung soll der Rückgabewert denn haben?




Wenn Du schon einen boolean-Parameter aufsteigend hast, dann brauchst Du keinen zusätzlichen Parameter absteigend, denn "nicht aufsteigend" ist gleichbedeutend mit absteigend :)



Du kannst auch boolean antwort = scanner.nextBoolean(); benutzen. Dann muss der Anwender "true" oder "false" eingeben und Du brauchst keinen Vergleich durchzuführen.


Nein, da kannst Du jetzt den Effekt nutzen, den Du vor dem Kopieren des Arrays hattest. Dazu kommen wir vermutlich später nochmal :)

Ja also in der Aufgabenstellung steht halt, man soll von einem eingelesenen Array, diese funktion habe ich bereits schon. Diesen sortieren und als Rückgabewert soll es ein boolean sein.

"Beim Programmieren mit Arrays werden in verschiedenen Aufgaben immer wieder die gleichen Funktionen benötigt. Dazu gehört: Maximum im Array und ist das Array sortiert? Implementie-ren Sie diese Funktionen. Für die erste Funktion soll der Index des entsprechenden Elements zurückgegeben werden. Die zweite Funktion gibt einen Boolean zurück. "
 
K

kneitzel

Gast
Das ist dann aber nicht die Sortieren Funktion, sondern eine Funktion "istDasArraySortiert".

Und ja, da kommt dann ein boolean raus.
 
K

kneitzel

Gast
Ja doch, natürlich geht das. Die Frage "Ist das Array sortiert?" ist eine klare Ja / Nein Frage. Aber aus der Antwort Ja kannst Du nicht schließen, wie es sortiert ist.

Ist das Auto lackiert? -> Ja / Nein Frage. Aber welche Farbe das Auto hat, wenn es denn lackiert wurde, ist offen.

Das ist auch das, worauf man immer aufpassen muss! Du hast klare Namen und die müssen stimmig sein!

Und das ist oft schwer. Ist das Array sortiert? Dein Array mit Eingaben ist auch sortiert! Und zwar liegen die Eingaben sortiert nach ihrer Eingabefolge vor. Die zuerst eingegebene Zahl ist an erster Stelle, die zweite Zahl an zweiter Stelle, u.s.w....

Oder stell Dir als Sortierkriterium vor, dass Du von jeder Zahl die Quadratwurzel nimmst um dann nur die Nachkommastellen zu werten (also immer 0,<Nachkommastellen der Quadratwurzel>) ...

Aber das ist jetzt Haarspaltereien. Man sollte sich auf seine (vereinfachte) Problemdomäne beziehen und die bedeutet bei dir: Aufsteigend und Absteigend. Und danach prüfst Du dann ein Array.
 

mihe7

Top Contributor
Doch, Du kannst der Methode ja auch mitgeben, ob sie nach aufsteigender Sortierung prüfen soll, oder nicht.

Der Ansatz ist trivial:
Java:
public boolean istSortiert(int[] werte, boolean aufsteigend) {
    for (int i = 0; i < werte.length-1; i++) {
        if (werte[i] > werte[i+1]) {
            return false;
        }
    }
    return true;
}
Das boolean aufsteigend darfst Du jetzt aber selbst einbauen :)
 

pureGewalt

Mitglied
OK, mit dieser Methode würde ich quasie prüfen ob mein Array sortiert ist oder nicht, und das bekomme ich auch als Rückgabe. Wenn es ich sortieren lassen möchte muss ich ja dann noch eine Extra Methode schreiben, ich kann ja schlecht zwei Rückgabewerte in eine Methode packen. Das probiere ich dann mal.

Ich danke euch sehr für die Hilfe!
 

mihe7

Top Contributor
mit dieser Methode würde ich quasie prüfen ob mein Array sortiert ist oder nicht, und das bekomme ich auch als Rückgabe.
Richtig.

Wenn es ich sortieren lassen möchte muss ich ja dann noch eine Extra Methode schreiben
Genau. Das Sortieren ist etwas anderes als das Prüfen, ob etwas sortiert ist. Übrigens auch von der Laufzeit her (die Prüfung geht schneller). Schon deswegen bieten sich zwei Methoden an.
 

pureGewalt

Mitglied
Also ich hatte es jetzt versucht mit zwei Methoden für auf und ab zu machen, doch da passiert wieder das dass mit den Referenzen nicht passt, da mein Array dann wieder kopiert werden muss, irgendwie wird das einfach zu viel dann. Sieht nicht schön aus. Ich verstehe leider immer noch nicht so leid es mir tut :D ... wie ich diese Methode auf und absteigend in eine Methode packe und das auch noch mit einer Benutzerabfrage. In der er wählen kann ob Auf oder Ab sortieren.
Meine Überlegung:
Wenn ich als Parameter das boolean absteigend überegebe muss ja irgendwie mit den 2 for schleifen es so sortiert werden das es für aufsteigend gilt. Einfach jetzt blind von mir gesagt boolean es gibt nur wahr und falsch mal angenommen diese bedingung ist nicht wahr -> also das es aufsteigend ist dann soll mir das boolean false zurückliefern aber wenn ich false als Aufsteigend erkläre, dann fehlt mir ja ein kompletter teil um dieses zu berechnen. I
 

mihe7

Top Contributor
Ich verstehe leider immer noch nicht so leid es mir tut :D ...
Das ist kein Wunder, wir haben ja eine Zeit lang aneinander vorbeigeschrieben.

Fangen wir nochmal von vorne mit der Aufgabenstellung an:
1. ermittle das Maximum im Array und gib dieses an die aufrufende Methode zurück
2. sortiere ein Arrays auf- oder absteigend und gib das Ergebnis an die aufrufende Methode zurück. Das übergebene Array soll dabei nicht verändert werden.
3. prüfe, ob ein Array aufsteigend bzw. absteigend sortiert ist.

Die Benutzereingaben sparen wir uns im Moment, wir kümmern uns nur um die Funktionalität.

Nemen wir mal folgenden Code:

Java:
public class Uebung {
    public static int maxImArray(int[] werte) {
        return 0;
    }

    public static int[] sortiereArray(int[] werte, boolean aufsteigend) {
        return new int[0];
    }

    public static boolean istSortiert(int[] werte, boolean aufsteigend) {
        return true;
    }


    public static void main(String[] args) {
        int[] eingaben = {6, 3, 4, 1, 9};
      
        // 1. Test: wir wissen, dass 9 das größte Element ist
        // daher sollte maxImArray für die eingaben auch 9 zurückgeben              
        // das können wir anhand er Ausgabe überprüfen
        int max = maxImArray(eingaben);
        System.out.println("1. Test: " + max);

        // 2. Test: wir wissen, dass die eingaben nicht sortiert sind
        // daher sollte istSortiert false zurückgeben.
        // das können wir anhand der Ausgabe überprüfen
        boolean sortiert = istSortiert(eingaben, true);
        System.out.println("2. Test: " + sortiert);
        
        // Wir sortieren nun das Array aufsteigend.
        // 3. Test: das ursprüngliche Array soll unangetastet bleiben        
        int[] ausgabe = sortiereArray(eingaben, true);
        System.out.println("3. Test: " + java.util.Arrays.toString(eingaben));

        // 4. Test: das sortierte Array soll sortiert sein
        System.out.println("4. Test: " + java.util.Arrays.toString(ausgabe));

        // 5. Test: die istSortiert-Methode muss für ausgabe
        // true zurückgeben
        sortiert = istSortiert(ausgabe, true);
        System.out.println("5. Test: " + sortiert);

        // Wiederholung der Tests 2 bis 5 nur für absteigende Sortierung
        sortiert = istSortiert(eingaben, false);
        System.out.println("6. Test: " + sortiert);
        ausgabe = sortiereArray(eingaben, false);
        System.out.println("7. Test: " + java.util.Arrays.toString(eingaben));
        System.out.println("8. Test: " + java.util.Arrays.toString(ausgabe));
        sortiert = istSortiert(ausgabe, false);
        System.out.println("9. Test: " + sortiert);
    }
}
Die main-Methode sieht vielleicht etwas viel und wüst aus, das meiste sind aber Kommentare. Letztlich geht es nur darum, uns anzeigen zu lassen, was die Methoden liefern bzw. gemacht haben, um überprüfen zu können, ob alles richtig ist.

Wenn alles stimmt, müsste am Ende rauskommen:
Code:
1. Test: 9
2. Test: false
3. Test: {6, 3, 4, 1, 9}
4. Test: {1, 3, 4, 6, 9}
5. Test: true
6. Test: false
7. Test: {6, 3, 4, 1, 9}
8. Test: {9, 6, 4, 3, 1}
9. Test: true

Wenn Du den Code so laufen lässt, kommt natürlich etwas völlig anderes raus. Deine Aufgabe besteht nun darin, die Methoden maxImArray, sortiereArray und istSortiert sinnvoll zu implementieren. Parameter und Rückgabewerte dürfen nicht geändert werden. Ob die Implementierung richtig sein könnte, siehst Du jetzt bereits an der Ausgabe.
 

pureGewalt

Mitglied
Hey estmal wirklich vielen Dank für die ganze Hilfe, doch leider kriege ich das in mein Programm einfach nicht implementiert, sobald ich da irgendwas hinzufüge funktioniert auf einmal eine andere Methode nicht mehr richtig. Extrem merkwürdig, ich denke ich werde einfach nochmal nachfragen und abklären wie ich das hinkriege. Also nochmals vielen Dank für diese tolle Hilfe habe viel hinbekommen :)
 

pureGewalt

Mitglied
Alles klar dann Poste ich mal meinem Code saß jetzt echt ne weile dran und habe sehr viel hinbekommen, doch jetzt komme ich echt nicht mehr weiter, irgendwo übergebe ich einen Array falsch und zwar, sobald ich die Methode das Array erweiter nutze, benutzen alle Methoden immer noch das alte Array kann jemand den Fehler finden, ich verzweifle ...

Code:
import java.util.Arrays;

import java.util.Scanner;

public class ArraySortOderMax {

    public static void main(String[] args) {
        boolean exit = false;

        // Scanner aufrufen
        Scanner in = new Scanner(System.in);

        while (!exit) { // negation
            // Variablen Deklaration
            int n = 0;
            int z = 0;
            boolean menu = true;

            // Größe des Arrays erfragen
            System.out.println("Hallo, bitte geben Sie die größe Ihres Arrays ein: ");
            n = in.nextInt();

            // Prüfung das n einen sinnvollen wert annimmt
            if (n > 0) {

                // Array befüllen abfragen
                System.out.println("Geben Sie nun nach und nach Zahlen zum füllen ein: ");

                // Methoden Zuweisen und aufrufen
                int[] originalArray = arrayEinlesen(n, in);
                int[] kopieArray = new int[originalArray.length];
                for (int i = 0; i < originalArray.length; i++) {
                    kopieArray[i] = originalArray[i];
                }
                int[] kopieArray2 = new int[originalArray.length];
                for (int i = 0; i < originalArray.length; i++) {
                    kopieArray2[i] = originalArray[i];
                }

                int maximum = maxImArray(originalArray);
                boolean istSortiert = istDasArraySortiert(originalArray);
                int[] aufsteigend = sortiereAufsteigend(kopieArray);
                int[] absteigend = sortiereAbsteigend(kopieArray2);
               
               

                while (menu) { // wegen boolean
                    // Swtich Case anweisung das Menü erstellen
                    System.out.println("Willkommen im Menü");
                    System.out.println("Ihr eingebener Array");
                    System.out.println(Arrays.toString(originalArray));
                    System.out.println("Wählen Sie nun bitte was Sie mit Ihrem Array tun möchten\n");
                    System.out.println("Drücken Sie die 1 für den Index mit dem höchsten Wert");
                    System.out.println("Drücken Sie die 2 um zu Prüfen ob das Array Sortiert ist");
                    System.out.println("Drücken Sie die 3 um Ihr Array Aufsteigend zu sortieren");
                    System.out.println("Drücken Sie die 4 um Ihr Array Absteigend zu sortieren");
                    System.out.println("Drücken sie die 5 um ihr Array zu erweitern");
                    System.out.println("Drücken Sie die 6 um ein neues Array einzugeben");
                    System.out.println("Drücken Sie die -1 um das Programm zu beenden");

                    z = in.nextInt();
                    switch (z) {
                    case 1:
                        System.out.println("Der Index der den Höchsten Wert besitzt ist: " + maximum + "\n\n");
                        break;
                    case 2:
                        System.out.println("Ihr Array ist Sortiert: " + istSortiert + "\n\n");
                        break;
                    case 3:
                        System.out.println("Bitte sehr Aufsteigend sortiert: ");
                        System.out.println(Arrays.toString(aufsteigend));
                        break;
                    case 4:
                        System.out.println("Bitte sehr Absteigend sortiert");
                        System.out.println(Arrays.toString(absteigend));
                        break;
                    case 5:
                        System.out.println("Ihr erweitertes Array");
                        originalArray = arrayErweitern(in, originalArray);
                        System.out.println(Arrays.toString(originalArray));
                        break;
                    case 6:
                        menu = false;
                        break;

                    case -1:
                        System.out.println("Ende");
                        System.out.println("Bis bald :-)");
                        exit = true;
                        menu = false;
                        break;
                       
                    default:
                        System.out.println("Falsche Eingabe");
                        break;
                    }// ende von Switch / case

                }

            } else {

                System.out.println("ERROR : Machen Sie eine gültige eingabe!");
                System.out.println("Ihr Programm muss neu gestartet werden.");
            }

        }
        in.close();

    }// ende von main

    // Methoden
    public static int[] arrayEinlesen(int n, Scanner in) {

        // Deklaration
        int[] originalArray = new int[n];
        int i = 0;
        int eingabe = 0;

        while (i < n) {
            eingabe = in.nextInt();
            originalArray[i] = eingabe;
            i++;
        }
     
        return originalArray;

    }// ende von arrayEinlesen

    public static int maxImArray(int[] originalArray) { // zugriff auf Rückgabewert von anderer Methode
        int maxIndex = 0;
        int max = 0; 
        for (int index = 0; index < originalArray.length; index++) {
            if (originalArray[index] > max) {
                max = originalArray[index];
                maxIndex = index;
            }

        }
        // Rückgabewert des höchsten wertes
        return maxIndex;

    }// ende von maxImArray

    public static boolean istDasArraySortiert(int originalArray[]) {
        for (int i = 0; i < originalArray.length - 1; i++) {
            if (originalArray[i] > originalArray[i + 1]) {
                return false;
            }
        }
        return true;

    }// ende von istDasArraySortiert

    public static int[] sortiereAufsteigend(int originalArray[]) {

        for (int i = 0; i < originalArray.length; i++) {
            for (int j = i; j < originalArray.length; j++) {
                if (originalArray[i] > originalArray[j]) {
                    int zwischenSpeicherAufsteigend = originalArray[i];
                    originalArray[i] = originalArray[j];
                    originalArray[j] = zwischenSpeicherAufsteigend;
                }
            }

        }
        return originalArray;

    }// ende von sortiereAufsteigend

    public static int[] sortiereAbsteigend(int originalArray[]) {

        for (int i = 0; i < originalArray.length; i++) {
            for (int j = i; j < originalArray.length; j++) {
                if (originalArray[i] < originalArray[j]) {
                    int zwischenSpeicherAbsteigend = originalArray[i];
                    originalArray[i] = originalArray[j];
                    originalArray[j] = zwischenSpeicherAbsteigend;
                }
            }
        }
        return originalArray;

    }// ende von sortiereAbsteigend

    public static int[] arrayErweitern(Scanner in, int originalArray[]) {
        System.out.println("Wie viele Werte hinzugefügt werden?");
        int tmp = in.nextInt();
        System.out.println("Geben Sie nun die Werte zum füllen ein: ");
        int[] arrayErweitert = arrayEinlesen(tmp, in);
        int[] tmpArray = new int[tmp + originalArray.length];
        for (int i = 0; i < originalArray.length; i++) {
            tmpArray[i] = originalArray[i];
        }
        for (int i = 0; i < tmp; i++) {
            tmpArray[i + originalArray.length] = arrayErweitert[i];
        }
        return tmpArray;

    }// ende von arrayErweitern

}// ende von ArraySortOderMax

Ich bedanke mich für jegliche Hilfe, weiß jetzt aber nicht mehr weiter leider.

Grüße
 

pureGewalt

Mitglied
Ah und Sorry für DoppelPost, ich soll hier noch diese Funktion implementieren, da fehlt mir leider noch ein Ansatz :/ hat jemand noch eine Idee für mich?

Zusätzlich soll es eine Funktion geben, die das bereits eingegebene Array filtert. Alle Zahlen, die Quadratzahlen sind (z.B.: 4, 9, 16, 25) sollen in ein neues Array kopiert werden. Dieses neue Array soll zurückgegeben werden aber nicht das eingegebene Array ersetzen.

Danke euch für jegliche Antworten :) bis bald
 

mihe7

Top Contributor
Ich bedanke mich für jegliche Hilfe, weiß jetzt aber nicht mehr weiter leider.
Das bekommen wir schon noch hin.

Jetzt sehe ich gerade, dass maxImArray den Index des maximalen Werts und nicht den Wert selbst zurückgeben soll. Dann stimmt mein Test in Klasse Uebung oben natürlich nicht. Das nebenbei.

Unabhängig davon ist Deine Methode maxImArray nicht ganz korrekt. Erstens muss man sich überlegen, was passieren soll, wenn Du ein leeres Array bekommst. Da könnte man z. B. -1 zurückgeben, da es keine negativen Indizes gibt.

Zweitens: wenn Dein Array nur aus negativen Werten besteht, bekommst Du 0 zurück. Es gibt - wie immer - verschiedene Möglichkeiten, damit umzugehen. Die m. E. klarste ist, wenn Du max nicht mit 0 sondern mit dem ersten Element des Arrays initialisierst. In der Schleife kannst Du dann bei Index 1 beginnen.

Die istDasArraySortiert-Methode sollte passen - für den aufsteigenden Fall. Der absteigende Fall sieht natürlich genauso aus, nur dass der Kleiner-Operator verwendet werden muss.

sobald ich die Methode das Array erweiter nutze, benutzen alle Methoden immer noch das alte Array kann jemand den Fehler finden, ich verzweifle ...
Naja, wo verwendest Du denn in Deinem Menü-Schleife das originalArray? Du solltest in den cases Deine Methoden aufrufen und in den jeweiligen Methoden die Kopien anlegen.


Zusätzlich soll es eine Funktion geben, die das bereits eingegebene Array filtert. Alle Zahlen, die Quadratzahlen sind (z.B.: 4, 9, 16, 25) sollen in ein neues Array kopiert werden. Dieses neue Array soll zurückgegeben werden aber nicht das eingegebene Array ersetzen.
Das funktioniert im Prinzip wie das Kopieren, nur dass Du nicht jedes Element kopierst, sondern nur diejenigen, auf die die Filterbedingung zutrifft.
 

pureGewalt

Mitglied
Ich denke mal ich habe es total Falsch gemacht weil jetzt kommen gar keine richtigen Werte mehr raus :D

Code:
import java.util.Arrays;

import java.util.Scanner;

public class ArraySortOderMax {

    public static void main(String[] args) {
        boolean exit = false;

        // Scanner aufrufen
        Scanner in = new Scanner(System.in);

        while (!exit) { // negation
            // Variablen Deklaration
            int n = 0;
            int z = 0;
            boolean menu = true;

            // Größe des Arrays erfragen
            System.out.println("Hallo, bitte geben Sie die größe Ihres Arrays ein: ");
            n = in.nextInt();

            // Prüfung das n einen sinnvollen wert annimmt
            if (n > 0) {

                // Array befüllen abfragen
                System.out.println("Geben Sie nun nach und nach Zahlen zum füllen ein: ");

                // Methoden Zuweisen und aufrufen
                int[] originalArray = arrayEinlesen(n, in);
                int[] kopieArray = new int[originalArray.length];
                int[] kopieArray2 = new int[originalArray.length];

                while (menu) { // wegen boolean
                    // Swtich Case anweisung das Menü erstellen
                    System.out.println("Willkommen im Menü");
                    System.out.println("Ihr eingebener Array");
                    System.out.println(Arrays.toString(originalArray));
                    System.out.println("Wählen Sie nun bitte was Sie mit Ihrem Array tun möchten\n");
                    System.out.println("Drücken Sie die 1 für den Index mit dem höchsten Wert");
                    System.out.println("Drücken Sie die 2 um zu Prüfen ob das Array Sortiert ist");
                    System.out.println("Drücken Sie die 3 um Ihr Array Aufsteigend zu sortieren");
                    System.out.println("Drücken Sie die 4 um Ihr Array Absteigend zu sortieren");
                    System.out.println("Drücken sie die 5 um ihr Array zu erweitern");
                    System.out.println("Drücken Sie die 6 um ein neues Array einzugeben");
                    System.out.println("Drücken Sie die -1 um das Programm zu beenden");

                    z = in.nextInt();
                    switch (z) {
                    case 1:
                        int maximum = maxImArray(originalArray);
                        System.out.println("Der Index der den Höchsten Wert besitzt ist: " + maximum + "\n\n");
                        break;
                    case 2:
                        boolean istSortiert = istDasArraySortiert(originalArray);
                        System.out.println("Ihr Array ist Sortiert: " + istSortiert + "\n\n");
                        break;
                    case 3:
                        int[] aufsteigend = sortiereAufsteigend(kopieArray, originalArray);
                        System.out.println("Bitte sehr Aufsteigend sortiert: ");
                        System.out.println(Arrays.toString(aufsteigend));
                        break;
                    case 4:
                        int[] absteigend = sortiereAbsteigend(kopieArray2, originalArray);
                        System.out.println("Bitte sehr Absteigend sortiert");
                        System.out.println(Arrays.toString(absteigend));
                        break;
                    case 5:
                        System.out.println("Ihr erweitertes Array");
                        originalArray = arrayErweitern(in, originalArray);
                        System.out.println(Arrays.toString(originalArray));
                        break;
                    case 6:
                        menu = false;
                        break;

                    case -1:
                        System.out.println("Ende");
                        System.out.println("Bis bald :-)");
                        exit = true;
                        menu = false;
                        break;

                    default:
                        System.out.println("Falsche Eingabe");
                        break;
                    }// ende von Switch / case

                }

            } else {

                System.out.println("ERROR : Machen Sie eine gültige eingabe!");
                System.out.println("Ihr Programm muss neu gestartet werden.");
            }

        }
        in.close();

    }// ende von main

    // Methoden
    public static int[] arrayEinlesen(int n, Scanner in) {

        // Deklaration
        int[] originalArray = new int[n];
        int i = 0;
        int eingabe = 0;

        while (i < n) {
            eingabe = in.nextInt();
            originalArray[i] = eingabe;
            i++;
        }
        // Rückgabewert des Arrays a
        return originalArray;

    }// ende von arrayEinlesen

    public static int maxImArray(int[] originalArray) { // zugriff auf Rückgabewert von anderer Methode
        int maxIndex = 0;
        int max = originalArray[0];
        for (int index = 1; index < originalArray.length; index++) {
            if (originalArray[index] > max) {
                max = originalArray[index];
                maxIndex = index;
            }

        }
        // Rückgabewert des höchsten wertes
        return maxIndex;

    }// ende von maxImArray

    public static boolean istDasArraySortiert(int originalArray[]) {
        for (int i = 0; i < originalArray.length - 1; i++) {
            if (originalArray[i] > originalArray[i + 1]) {
                return false;
            }
        }
        return true;

    }// ende von istDasArraySortiert

    public static int[] sortiereAufsteigend(int originalArray[], int kopieArray[]) {

        for (int i = 0; i < originalArray.length; i++) {
            for (int j = i; j < originalArray.length; j++) {
                if (originalArray[i] > originalArray[j]) {
                    int zwischenSpeicherAufsteigend = originalArray[i];
                    originalArray[i] = originalArray[j];
                    originalArray[j] = zwischenSpeicherAufsteigend;

                    for (int k = 0; i < originalArray.length; k++) {
                        kopieArray[k] = originalArray[k];
                    }
                }
            }

        }
        return originalArray;

    }// ende von sortiereAufsteigend

    public static int[] sortiereAbsteigend(int originalArray[], int kopieArray2[]) {

        for (int i = 0; i < originalArray.length; i++) {
            for (int j = i; j < originalArray.length; j++) {
                if (originalArray[i] < originalArray[j]) {
                    int zwischenSpeicherAbsteigend = originalArray[i];
                    originalArray[i] = originalArray[j];
                    originalArray[j] = zwischenSpeicherAbsteigend;

                    for (int k = 0; k < originalArray.length; k++) {
                        kopieArray2[i] = originalArray[i];
                    }
                }
            }
        }
        return originalArray;

    }// ende von sortiereAbsteigend

    public static int[] arrayErweitern(Scanner in, int originalArray[]) {
        System.out.println("Wie viele Werte hinzugefügt werden?");
        int tmp = in.nextInt();
        System.out.println("Geben Sie nun die Werte zum füllen ein: ");
        int[] arrayErweitert = arrayEinlesen(tmp, in);
        int[] tmpArray = new int[tmp + originalArray.length];
        for (int i = 0; i < originalArray.length; i++) {
            tmpArray[i] = originalArray[i];
        }
        for (int i = 0; i < tmp; i++) {
            tmpArray[i + originalArray.length] = arrayErweitert[i];
        }
        return tmpArray;

    }// ende von arrayErweitern

}// ende von ArraySortOderMax
 

mihe7

Top Contributor
Du denkst zu kompliziert. Mach es einfach wie für die Doofen: gib Deiner Sortiermethode das Original. In der Sortiermethode legst Du eine Kopie davon an und diese Kopie sortierst Du und gibst sie am Ende zurück.

Du kannst Dir eine Methode schreiben für das Kopieren:
Java:
public static int[] erstelleKopie(int[] original) {
    int[] kopie = new int[original.length];
    for (int i = 0; i < original.length; i++) {
        kopie[i] = original[i];
    }
    return kopie;
}

Deine Sortiermethoden sehen dann so aus:
Java:
    public static int[] sortiereAbsteigend(int originalArray[]) {
        int[] kopie = erstelleKopie(original);
        // hier das Array kopie sortieren
        return kopie;
    }

Dadurch wird der Code erstmal klarer.

Die Zeilen
Java:
                int[] kopieArray = new int[originalArray.length];
                int[] kopieArray2 = new int[originalArray.length];
in main() kommen dann weg.
 

pureGewalt

Mitglied
Mihe7 ! Ich glaub jetzt müsste erstmal alles passen, danke für deine Hilfe jetzt muss ich mir nur noch was überlegen für die quadratischen Zahlen und dann müsste ich endlcih durch sein. Danke für dein großzügige hilfe und das du so geduldig mit mir bist :) :D !!
Code:
import java.util.Arrays;

import java.util.Scanner;

public class ArraySortOderMax {

    public static void main(String[] args) {
        boolean exit = false;

        // Scanner aufrufen
        Scanner in = new Scanner(System.in);

        while (!exit) { // negation
            // Variablen Deklaration
            int n = 0;
            int z = 0;
            boolean menu = true;

            // Größe des Arrays erfragen
            System.out.println("Hallo, bitte geben Sie die größe Ihres Arrays ein: ");
            n = in.nextInt();

            // Prüfung das n einen sinnvollen wert annimmt
            if (n > 0) {

                // Array befüllen abfragen
                System.out.println("Geben Sie nun nach und nach Zahlen zum füllen ein: ");

                // Methoden Zuweisen und aufrufen
                int[] originalArray = arrayEinlesen(n, in);

                while (menu) { // wegen boolean
                    // Swtich Case anweisung das Menü erstellen
                    System.out.println("Willkommen im Menü");
                    System.out.println("Ihr eingebener Array");
                    System.out.println(Arrays.toString(originalArray));
                    System.out.println("Wählen Sie nun bitte was Sie mit Ihrem Array tun möchten\n");
                    System.out.println("Drücken Sie die 1 für den Index mit dem höchsten Wert");
                    System.out.println("Drücken Sie die 2 um zu Prüfen ob das Array Sortiert ist");
                    System.out.println("Drücken Sie die 3 um Ihr Array Aufsteigend zu sortieren");
                    System.out.println("Drücken Sie die 4 um Ihr Array Absteigend zu sortieren");
                    System.out.println("Drücken sie die 5 um ihr Array zu erweitern");
                    System.out.println("Drücken Sie die 6 um ein neues Array einzugeben");
                    System.out.println("Drücken Sie die -1 um das Programm zu beenden");

                    z = in.nextInt();
                    switch (z) {
                    case 1:
                        int maximum = maxImArray(originalArray);
                        System.out.println("Der Index der den Höchsten Wert besitzt ist: " + maximum + "\n\n");
                        break;
                    case 2:
                        boolean istSortiert = istDasArraySortiert(originalArray);
                        System.out.println("Ihr Array ist Sortiert: " + istSortiert + "\n\n");
                        break;
                    case 3:
                        int[] aufsteigend = sortiereAufsteigend(originalArray);
                        System.out.println("Bitte sehr Aufsteigend sortiert: ");
                        System.out.println(Arrays.toString(aufsteigend));
                        break;
                    case 4:
                        int[] absteigend = sortiereAbsteigend(originalArray);
                        System.out.println("Bitte sehr Absteigend sortiert");
                        System.out.println(Arrays.toString(absteigend));
                        break;
                    case 5:
                        originalArray = arrayErweitern(in, originalArray);
                        System.out.println(Arrays.toString(originalArray));
                        break;
                    case 6:
                        menu = false;
                        break;

                    case -1:
                        System.out.println("Ende");
                        System.out.println("Bis bald :-)");
                        exit = true;
                        menu = false;
                        break;

                    default:
                        System.out.println("Falsche Eingabe");
                        break;
                    }// ende von Switch / case

                }

            } else {

                System.out.println("ERROR : Machen Sie eine gültige eingabe!");
                System.out.println("Ihr Programm muss neu gestartet werden.");
            }

        }
        in.close();

    }// ende von main

    // Methoden
    public static int[] arrayEinlesen(int n, Scanner in) {

        // Deklaration
        int[] originalArray = new int[n];
        int i = 0;
        int eingabe = 0;

        while (i < n) {
            eingabe = in.nextInt();
            originalArray[i] = eingabe;
            i++;
        }
        // Rückgabewert des Arrays a
        return originalArray;

    }// ende von arrayEinlesen

    public static int maxImArray(int[] originalArray) { // zugriff auf Rückgabewert von anderer Methode
        int maxIndex = 0;
        int max = originalArray[0];
        for (int index = 1; index < originalArray.length; index++) {
            if (originalArray[index] > max) {
                max = originalArray[index];
                maxIndex = index;
            }

        }
        // Rückgabewert des höchsten wertes
        return maxIndex;

    }// ende von maxImArray

    public static boolean istDasArraySortiert(int originalArray[]) {
        for (int i = 0; i < originalArray.length - 1; i++) {
            if (originalArray[i] > originalArray[i + 1]) {
                return false;
            }
        }
        return true;

    }// ende von istDasArraySortiert

    // methode um das Array zu kopiere
    public static int[] erstelleKopie(int[] originalArray) {
        int[] kopie = new int[originalArray.length];
        for (int i = 0; i < originalArray.length; i++) {
            kopie[i] = originalArray[i];
        }
        return kopie;
    }

    public static int[] sortiereAufsteigend(int originalArray[]) {

        int[] kopie = erstelleKopie(originalArray);
        for (int i = 0; i < kopie.length; i++) {
            for (int j = i; j < kopie.length; j++) {
                if (kopie[i] > kopie[j]) {
                    int zwischenSpeicherAufsteigend = kopie[i];
                    kopie[i] = kopie[j];
                    kopie[j] = zwischenSpeicherAufsteigend;

                }

            }
        }
        return kopie;

    }// ende von sortiereAufsteigend

    public static int[] sortiereAbsteigend(int originalArray[]) {

        int[] kopie = erstelleKopie(originalArray);
        for (int i = 0; i < kopie.length; i++) {
            for (int j = i; j < kopie.length; j++) {
                if (kopie[i] < kopie[j]) {
                    int zwischenSpeicherAbsteigend = kopie[i];
                    kopie[i] = kopie[j];
                    kopie[j] = zwischenSpeicherAbsteigend;

                }
            }

        }
        return kopie;

    }// ende von sortiereAbsteigend

    public static int[] arrayErweitern(Scanner in, int originalArray[]) {
        System.out.println("Wie viele Werte hinzugefügt werden?");
        int tmp = in.nextInt();
        System.out.println("Geben Sie nun die Werte zum füllen ein: ");
        int[] arrayErweitert = arrayEinlesen(tmp, in);
        int[] tmpArray = new int[tmp + originalArray.length];
        for (int i = 0; i < originalArray.length; i++) {
            tmpArray[i] = originalArray[i];
        }
        for (int i = 0; i < tmp; i++) {
            tmpArray[i + originalArray.length] = arrayErweitert[i];
        }
        return tmpArray;

    }// ende von arrayErweitern

}// ende von ArraySortOderMax
 

pureGewalt

Mitglied
Ich kriege es mal wieder nicht gebacken .... also ich möchte ja die quadratzahl, wann ist es überhaupt eine quadratzahl wenn die Wurzel daraus eine ganze Zahl ist. Da ich jetzt aber die ganze Zeit mit interger Arrays gearbeitet habe, meckert er immer bei der Math.sqrt() funktion das es in double konvertieren soll oder so. Wenn ich einen cast versuche klappt das nicht wirklich.

Aber zur Idee:
ich nehme am besten meine kopieren Funktion und weise diese wieder zu. Dann durchlaufe ich dieses Array und prüfe jeweils am ersten Index ob diese Zahl, die Wurzel daraus eine ganze Zahl ist oder?

Code:
public static int[] arrayFiltern(int originalArray[]) {
        int[] filterArray = erstelleKopie(originalArray);
        for(int index = 0; index < filterArray.length; index++) {
               
            
            }
        }

Komme da nicht darauf wie das dann nochmal durchlaufen lasse.

Danke nochmal für die Hilfe.
 

mihe7

Top Contributor
Vergiss erst mal den Code und versuche, in Worten (also ohne Code, wie in einem Kochrezept) zu beschreiben, wie das Programm arbeiten müsste.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
D Array List mit Objekten sortieren Java Basics - Anfänger-Themen 2
M Bubble Sort - Int[] Array sortieren Java Basics - Anfänger-Themen 2
B Array nach Elementwerten sortieren? Java Basics - Anfänger-Themen 1
L Gegebenes Array sortieren, indem zufällige Zahlenpaare aus Array ausgewählt werden Java Basics - Anfänger-Themen 14
G zweidimensionales int Array sortieren Java Basics - Anfänger-Themen 57
D Array Elemente sortieren in aufsteigender Reihenfolge Java Basics - Anfänger-Themen 10
javaluke Erste Schritte Array nach Datentyp sortieren Java Basics - Anfänger-Themen 16
O 2D-Array nach einer Spalte sortieren Java Basics - Anfänger-Themen 22
JD_1998 Random Array sortieren mit Hilfe einer Methode Java Basics - Anfänger-Themen 4
L Array sortieren Java Basics - Anfänger-Themen 4
L Java Int-Array, Zahlen sortieren Java Basics - Anfänger-Themen 8
T Java: Array monat absteigend sortieren? Java Basics - Anfänger-Themen 1
scratchy1 Array sortieren und dann String-Repräsentation ausgeben Java Basics - Anfänger-Themen 2
O Zweidimensional Array sortieren Java Basics - Anfänger-Themen 14
K Methoden Array[][] sortieren Java Basics - Anfänger-Themen 30
J String, Int und double Array sortieren Java Basics - Anfänger-Themen 16
A Array sortieren Java Basics - Anfänger-Themen 1
informatikschüler21 String im Array sortieren Java Basics - Anfänger-Themen 4
U Methoden Zweidimensionales Array mit Arrays.sort sortieren? Java Basics - Anfänger-Themen 22
W Array sortieren Java Basics - Anfänger-Themen 3
S array sortieren Java Basics - Anfänger-Themen 7
D Array mit Zufallszahlen, dann sortieren: Hilfe gesucht! Java Basics - Anfänger-Themen 1
D Methoden int-Array absteigend sortieren Java Basics - Anfänger-Themen 8
C OOP array Sortieren ohne den sort Befehl Java Basics - Anfänger-Themen 10
S int-Array mittels Arrays.sort() in einer Schleife sortieren. Java Basics - Anfänger-Themen 2
D Erste Schritte array aufsteigend sortieren und ausgeben Java Basics - Anfänger-Themen 17
C Werte im Array sortieren Java Basics - Anfänger-Themen 5
A Input/Output 2-dimensionales array sortieren Java Basics - Anfänger-Themen 3
J Array nach häufigkeit sortieren Java Basics - Anfänger-Themen 4
S Strings im Array nach Namen sortieren Java Basics - Anfänger-Themen 11
E Array sortieren, es will nicht Java Basics - Anfänger-Themen 6
B Problrm beim Array sortieren Java Basics - Anfänger-Themen 0
S Mehrdimensionales Array sortieren Java Basics - Anfänger-Themen 3
G Array mit BubbleSort sortieren Java Basics - Anfänger-Themen 2
F Array mit Zufallszahlen sortieren Java Basics - Anfänger-Themen 7
N Array sortieren Java Basics - Anfänger-Themen 6
J Methoden Einzelnen Wert aus Objekt aus einem Array auslesen und danach sortieren Java Basics - Anfänger-Themen 8
T Sortieren/Suche klappt nicht ganz (String Array) Java Basics - Anfänger-Themen 2
L Array Sortieren Java Basics - Anfänger-Themen 3
H Sortieren von Array Java Basics - Anfänger-Themen 7
K 2D-Array sortieren Java Basics - Anfänger-Themen 7
I Objekte in einem Array sortieren Java Basics - Anfänger-Themen 19
K Array sortieren Java Basics - Anfänger-Themen 19
P String Sortieren in einem Array Java Basics - Anfänger-Themen 7
T Strings mit compareto vergleichen und array sortieren Java Basics - Anfänger-Themen 14
B Array nach dem Alphabet sortieren Java Basics - Anfänger-Themen 11
J Array mit Objekten sortieren Java Basics - Anfänger-Themen 11
S Array sortieren NULL oder Empty ignorieren. Java Basics - Anfänger-Themen 9
S Array sortieren und ausgeben Java Basics - Anfänger-Themen 3
C zweidimensionales Array sortieren Java Basics - Anfänger-Themen 6
W Objekte in einer Array sortieren Java Basics - Anfänger-Themen 3
R 2D Array sortieren Java Basics - Anfänger-Themen 11
A String-Array lexikographisch sortieren Java Basics - Anfänger-Themen 6
A Array einer eigenen Klasse sortieren Java Basics - Anfänger-Themen 11
J 2D Array mit Zeilenverschiebung Sortieren Java Basics - Anfänger-Themen 15
B Zufällige Zahlen in Array sortieren Java Basics - Anfänger-Themen 18
c_sidi90 Array mit Bubblesort sortieren Java Basics - Anfänger-Themen 8
D OOP mit compareTo Array sortieren (aus zwei Klassen) Java Basics - Anfänger-Themen 3
E Array Sortieren Java Basics - Anfänger-Themen 3
B Array durchlaufen und sortieren Java Basics - Anfänger-Themen 9
L Einzeiler - String Array sortieren Java Basics - Anfänger-Themen 16
J Array aufsteigend sortieren Java Basics - Anfänger-Themen 10
D Array nach ungerade zahlen sortieren Java Basics - Anfänger-Themen 6
A Sortieren von Zahlen in einem Array Java Basics - Anfänger-Themen 13
T Zahlen in ARRAY Sortieren Java Basics - Anfänger-Themen 10
N sortieren zweier abhängiger array listen Java Basics - Anfänger-Themen 12
N Array sortieren - Java Basics - Anfänger-Themen 7
T Array mit Integern sortieren Java Basics - Anfänger-Themen 9
M Array anders sortieren, aber die Reihenfolge beibehalten Java Basics - Anfänger-Themen 4
kulturfenster Array mit Strings sortieren Java Basics - Anfänger-Themen 7
D Mehrdimensionales Array sortieren Java Basics - Anfänger-Themen 5
G Array List sortieren / auswerten Java Basics - Anfänger-Themen 24
B 2D-Array (Tabelle) alphabetisch sortieren Java Basics - Anfänger-Themen 6
S array nach 2 kriterien sortieren Java Basics - Anfänger-Themen 3
R Array sortieren Java Basics - Anfänger-Themen 12
G 2D-Array sortieren Java Basics - Anfänger-Themen 11
M ArrayList in Array, dann sortieren Java Basics - Anfänger-Themen 15
R Array sortieren Java Basics - Anfänger-Themen 2
B 2D Array sortieren Java Basics - Anfänger-Themen 15
I Array sortieren oder Tabelle sortieren ? Java Basics - Anfänger-Themen 2
M 2-dimensionales Array sortieren Java Basics - Anfänger-Themen 2
R String-Array sortieren Java Basics - Anfänger-Themen 12
P Array verkleinern und sortieren Java Basics - Anfänger-Themen 11
I Zahlen in Array schreiben und dann sortieren Java Basics - Anfänger-Themen 7
G float-Array _ohne_ Arrays.sort sortieren Java Basics - Anfänger-Themen 5
P Array füllen & sortieren Java Basics - Anfänger-Themen 3
J Array sortieren Java Basics - Anfänger-Themen 4
M Array mit Werten füllen und sortieren Java Basics - Anfänger-Themen 2
O Array sortieren Java Basics - Anfänger-Themen 3
D erste spalte eines zweidimensionales Array sortieren ??!! Java Basics - Anfänger-Themen 2
T Array verkleinern Java Basics - Anfänger-Themen 2
J Array aus Numberfield Eingaben Java Basics - Anfänger-Themen 7
onlyxlia Anzahl Random Zahlen mit Scanner abfragen und in Array speichern Java Basics - Anfänger-Themen 10
Ü Java Array - Buchstaben als Zahlen ausgeben Java Basics - Anfänger-Themen 22
Ü Zweidimensionales Array in der ersten Zeile deklarieren Java Basics - Anfänger-Themen 13
Thomas Uppe 2D Array Reihenfolge vermischen Java Basics - Anfänger-Themen 4
T array auslesen Java Basics - Anfänger-Themen 2
Nitrogames Variablen Variable aus JOptionPane Abfrage in Array einfügen Java Basics - Anfänger-Themen 4
moini Auf Array aus Superklasse zugreifen? Java Basics - Anfänger-Themen 2
J ArrayList in 2D-Array konvertieren. Java Basics - Anfänger-Themen 48

Ähnliche Java Themen

Neue Themen


Oben