Struktogramm für Merge-Sort

[schneemil]

Hi, ich möchte ein Struktogramm für mein Merge-Sort Code erstellen und möchte fragen ob das so schon passend ist, oder ob ich da noch was verbessern müsste?
Link Struktogramm: https://struktog.openpatch.org/#pak...ol0VR0vwG_i9Wa-8s1Po4hXqxe9XVar56E6K9_BepynRQ

import java.util.Arrays;
import java.util.Random;

public class MergeSortWithMetrics {
    // Zähler für Sortierschritte
    static long comparisons = 0;
    static long assignments = 0;

    public static void main(String[] args) {
        // Konfiguration: Array-Größe und Zahlbereich
        int arraySize = 10000; // Größe des Arrays
        int numberRange = 214748647; // Bereich der Zufallszahlen (0 bis numberRange)
        boolean ArrayAusgebenAn = false;
        boolean StatistikenAn = true;
        

        // Zufälliges Array erstellen
        int[] array = generateRandomArray(arraySize, numberRange);


        if (ArrayAusgebenAn){
            System.out.println("Unsortiertes Array:");
            System.out.println(Arrays.toString(array));
        }
      

        // Zeitmessung starten
        long startTime = System.currentTimeMillis();

        // MergeSort aufrufen
        int[] sortedArray = mergeSort(array);

        // Zeitmessung beenden
        long endTime = System.currentTimeMillis();

        // Sortiertes Array ausgeben
        if (ArrayAusgebenAn){
        System.out.println("Sortiertes Array:");
        System.out.println(Arrays.toString(sortedArray));
        }
        

        // Statistiken ausgeben
        if (StatistikenAn){
        System.out.println("Sortierschritte:");
        System.out.println("Vergleiche: " + comparisons);
        System.out.println("Zuweisungen: " + assignments);
        System.out.println("Zeitmessung: " + (endTime - startTime) + " ms");
        }
        
    }

    // Funktion, um ein zufälliges Array zu generieren
    public static int[] generateRandomArray(int size, int range) {
        Random random = new Random();
        int[] array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = random.nextInt(range);
        }
        return array;
    }

    // MergeSort-Algorithmus
    public static int[] mergeSort(int[] array) {
        if (array.length <= 1) {
            return array;
        }

        // Array in zwei Hälften teilen
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);

        // Rekursive Sortierung der Hälften
        left = mergeSort(left);
        right = mergeSort(right);

        // Zusammenfügen der sortierten Hälften
        return merge(left, right);
    }

    // Merge-Funktion: Zwei sortierte Arrays zusammenfügen
    public static int[] merge(int[] left, int[] right) {
        int[] merged = new int[left.length + right.length];
        int i = 0, j = 0, k = 0;

        // Elemente vergleichen und in das neue Array einfügen
        while (i < left.length && j < right.length) {
            comparisons++;
            if (left[i] <= right[j]) {
                merged[k++] = left[i++];
            } else {
                merged[k++] = right[j++];
            }
            assignments++;
        }

        // Restliche Elemente hinzufügen
        while (i < left.length) {
            merged[k++] = left[i++];
            assignments++;
        }

        while (j < right.length) {
            merged[k++] = right[j++];
            assignments++;
        }

        return merged;
    }
}

 

[KonradN]

Also die Bedingungen solltest du genau prüfen.
a) Wiederhole bis die Liste vollständig sortiert ist - wo siehst du so eine Schleife? Du hast doch eine Rekursion und die taucht nicht auf. Und damit stimmt auch die ganze Logik natürlich nicht. (Hier wären dann wohl auch zwei Struktogramme notwendig: Einmal für das mergesort(array) (was Du dann in der Beschreibung selbst auch nutzen kannst) und dann ein Struktogramm für die Sachen drumherum (die dann das mergesort nutzt, aber wird das überhaupt verlangt?).
b) "solange die Listenlänge der linken nicht i überschreitet" ist nicht i < links.length sondern ein <= links.length. Wieso drehst du die Formulier? Warum nicht einfach ein "solang i kleiner als die Länge der linken Liste ist" oder so.

Das wäre, was mir so direkt auffällt.