Array Sortieren mit boolean?

Bitte aktiviere JavaScript!
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
 
A

Anzeige


Vielleicht hilft dir dieser Kurs hier weiter: (hier klicken)
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.
 
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 :)
 
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
 
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
 
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.
 
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
 
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.
 
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
 
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.
 
Vergiss erst mal den Code und versuche, in Worten (also ohne Code, wie in einem Kochrezept) zu beschreiben, wie das Programm arbeiten müsste.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben