Berechnung des Medians einer Datensammlung in C

Einführung

In diesem Lab lernen Sie, wie man den Median eines Datensatzes in der C-Programmierung berechnet. Das Lab umfasst die folgenden Schritte: das Lesen und Sortieren eines Zahlenarrays, das Finden des mittleren Elements oder des Durchschnitts der beiden mittleren Elemente und das Drucken des Medians. Die schrittweisen Anweisungen führen Sie durch den Prozess der Implementierung dieser Aufgaben mithilfe der C-Programmierung, einschließlich Funktionen zum Lesen, Sortieren und Drucken des Arrays. Dieses Lab bietet einen praktischen Ansatz zum Verständnis und zur Anwendung statistischer Analysetechniken in C.

Lesen und Sortieren des Arrays

In diesem Schritt lernen Sie, wie Sie ein Zahlenarray lesen und sortieren, um den Median zu berechnen. Wir verwenden C-Programmierung, um diese Aufgabe zu erledigen.

Erstellen wir zunächst eine C-Datei zur Implementierung des Array-Lesens und -Sortierens:

cd ~/project
nano median_calculator.c

Fügen Sie nun folgenden Code in die Datei ein:

#include <stdio.h>

#define MAX_SIZE 100

// Funktion zum Lesen der Arrayelemente
void readArray(int arr[], int *n) {
    printf("Geben Sie die Anzahl der Elemente ein (max %d): ", MAX_SIZE);
    scanf("%d", n);

    printf("Geben Sie %d Elemente ein:\n", *n);
    for (int i = 0; i < *n; i++) {
        scanf("%d", &arr[i]);
    }
}

// Funktion zum Sortieren des Arrays mit dem Bubblesort-Algorithmus
void sortArray(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Elemente tauschen
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// Funktion zum Drucken des Arrays
void printArray(int arr[], int n) {
    printf("Sortiertes Array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[MAX_SIZE];
    int n;

    readArray(arr, &n);
    sortArray(arr, n);
    printArray(arr, n);

    return 0;
}

Kompilieren und ausführen des Programms:

gcc median_calculator.c -o median_calculator
./median_calculator

Beispielausgabe:

Geben Sie die Anzahl der Elemente ein (max 100): 5
Geben Sie 5 Elemente ein:
42
15
7
23
11
Sortiertes Array: 7 11 15 23 42

Zerlegung des Codes:

1. Die Funktion readArray() ermöglicht die Eingabe der Arrayelemente durch den Benutzer.
2. Die Funktion sortArray() verwendet den Bubblesort-Algorithmus, um die Elemente in aufsteigender Reihenfolge anzuordnen.
3. Die Funktion printArray() zeigt das sortierte Array an.
4. Die Funktion main() verknüpft diese Funktionen.

Der Bubblesort-Algorithmus hat eine Zeitkomplexität von O(n²), was einfach zu verstehen, aber für große Datensätze nicht die effizienteste Methode ist.

Mittleres Element oder Durchschnitt der beiden mittleren Elemente ermitteln

In diesem Schritt erweitern Sie das vorherige Programm, um den Median zu berechnen, indem Sie das mittlere Element oder den Durchschnitt der beiden mittleren Elemente in einem sortierten Array ermitteln.

Öffnen Sie die vorhandene Datei und ändern Sie den Code:

cd ~/project
nano median_calculator.c

Aktualisieren Sie den Code mit einer neuen Funktion zur Medianberechnung:

#include <stdio.h>

#define MAX_SIZE 100

// Vorherige Funktionen (readArray, sortArray, printArray) bleiben gleich

// Neue Funktion zur Medianberechnung
float calculateMedian(int arr[], int n) {
    // Wenn die Anzahl der Elemente ungerade ist, geben Sie das mittlere Element zurück
    if (n % 2 != 0) {
        return arr[n / 2];
    }

    // Wenn die Anzahl der Elemente gerade ist, geben Sie den Durchschnitt der beiden mittleren Elemente zurück
    int mid1 = arr[(n / 2) - 1];
    int mid2 = arr[n / 2];
    return (mid1 + mid2) / 2.0;
}

int main() {
    int arr[MAX_SIZE];
    int n;

    readArray(arr, &n);
    sortArray(arr, n);
    printArray(arr, n);

    // Median berechnen und ausgeben
    float median = calculateMedian(arr, n);
    printf("Median: %.2f\n", median);

    return 0;
}

Kompilieren und ausführen des aktualisierten Programms:

gcc median_calculator.c -o median_calculator
./median_calculator

Beispielausgabe für eine ungerade Anzahl von Elementen:

Geben Sie die Anzahl der Elemente ein (max 100): 5
Geben Sie 5 Elemente ein:
42
15
7
23
11
Sortiertes Array: 7 11 15 23 42
Median: 15.00

Beispielausgabe für eine gerade Anzahl von Elementen:

Geben Sie die Anzahl der Elemente ein (max 100): 6
Geben Sie 6 Elemente ein:
42
15
7
23
11
8
Sortiertes Array: 7 8 11 15 23 42
Median: 13.00

Wichtige Punkte zur Medianberechnung:

1. Bei einer ungeraden Anzahl von Elementen ist der Median das mittlere Element.
2. Bei einer geraden Anzahl von Elementen ist der Median der Durchschnitt der beiden mittleren Elemente.
3. Das Array muss vor der Medianberechnung sortiert werden.

Die Funktion calculateMedian() behandelt beide Fälle:

• Verwendet ganzzahlige Division, um den mittleren Index zu finden.
• Überprüft, ob die Anzahl der Elemente ungerade oder gerade ist.
• Gibt den entsprechenden Medianwert zurück.

Ausgabe des Medians

In diesem letzten Schritt erweitern Sie das Medianberechnungsprogramm, um detailliertere Ausgaben zu liefern und verschiedene Darstellungsweisen des Medians zu demonstrieren.

Öffnen Sie die vorhandene Datei, um die endgültigen Änderungen vorzunehmen:

cd ~/project
nano median_calculator.c

Aktualisieren Sie den Code mit einer verbesserten Ausgabeformatierung:

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

// Vorherige Funktionen (readArray, sortArray, printArray, calculateMedian) bleiben gleich

void printDetailedMedianInfo(int arr[], int n, float median) {
    printf("\n--- Details zur Medianberechnung ---\n");
    printf("Gesamtzahl der Elemente: %d\n", n);
    printf("Arrayelemente: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n\nMedianberechnung:\n");

    if (n % 2 != 0) {
        printf("Ungerade Anzahl von Elementen\n");
        printf("Mittlerer Index: %d\n", n / 2);
        printf("Mittleres Element: %d\n", arr[n / 2]);
    } else {
        printf("Gerade Anzahl von Elementen\n");
        printf("Zwei mittlere Indizes: %d und %d\n", (n / 2) - 1, n / 2);
        printf("Mittlere Elemente: %d und %d\n", arr[(n / 2) - 1], arr[n / 2]);
    }

    printf("\nEndgültiger Median: %.2f\n", median);
}

int main() {
    int arr[MAX_SIZE];
    int n;

    readArray(arr, &n);
    sortArray(arr, n);

    float median = calculateMedian(arr, n);

    // Sortiertes Array ausgeben
    printArray(arr, n);

    // Detaillierte Medianinformationen ausgeben
    printDetailedMedianInfo(arr, n, median);

    return 0;
}

Kompilieren und ausführen des aktualisierten Programms:

gcc median_calculator.c -o median_calculator
./median_calculator

Beispielausgabe für eine ungerade Anzahl von Elementen:

Geben Sie die Anzahl der Elemente ein (max 100): 5
Geben Sie 5 Elemente ein:
42
15
7
23
11
Sortiertes Array: 7 11 15 23 42

--- Details zur Medianberechnung ---
Gesamtzahl der Elemente: 5
Arrayelemente: 7 11 15 23 42

Medianberechnung:
Ungerade Anzahl von Elementen
Mittlerer Index: 2
Mittleres Element: 15

Endgültiger Median: 15.00

Beispielausgabe für eine gerade Anzahl von Elementen:

Geben Sie die Anzahl der Elemente ein (max 100): 6
Geben Sie 6 Elemente ein:
42
15
7
23
11
8
Sortiertes Array: 7 8 11 15 23 42

--- Details zur Medianberechnung ---
Gesamtzahl der Elemente: 6
Arrayelemente: 7 8 11 15 23 42

Medianberechnung:
Gerade Anzahl von Elementen
Zwei mittlere Indizes: 2 und 3
Mittlere Elemente: 11 und 15

Endgültiger Median: 13.00

Wichtige Verbesserungen in diesem Schritt:

1. Hinzufügen einer neuen Funktion printDetailedMedianInfo().
2. Bereitstellung umfassender Informationen zur Medianberechnung.
3. Darstellung verschiedener Szenarien für ungerade und gerade Anzahlen von Elementen.
4. Verbesserung des Benutzerverständnisses der Medianberechnung.

Zusammenfassung

In diesem Labor haben Sie gelernt, wie man ein Zahlenarray liest, es mithilfe des Bubblesort-Algorithmus sortiert und die Daten für die Berechnung des Medians vorbereitet. Das sortierte Array wird dann auf der Konsole ausgegeben, was die erfolgreiche Durchführung des ersten Schritts demonstriert. Der Bubblesort-Algorithmus, obwohl einfach zu verstehen, hat eine Zeitkomplexität von O(n²), was für große Datensätze möglicherweise nicht die effizienteste Methode ist. Die folgenden Schritte konzentrieren sich auf die Ermittlung des Medians des sortierten Arrays.

Der nächste Schritt beinhaltet die Identifizierung des mittleren Elements oder des Durchschnitts der beiden mittleren Elemente, abhängig von der Größe des Arrays. Dieser Schritt stellt sicher, dass der Median korrekt berechnet und dem Benutzer präsentiert wird.