Calculer la Médiane d'un Jeu de Données en C

Introduction

Dans ce laboratoire, vous apprendrez à calculer la médiane d'un ensemble de données en langage C. Le laboratoire couvre les étapes suivantes : la lecture et le tri d'un tableau de nombres, la recherche de l'élément du milieu ou de la moyenne des deux éléments du milieu, et l'impression de la médiane. Les instructions étape par étape vous guident à travers le processus de mise en œuvre de ces tâches en utilisant le langage C, y compris les fonctions de lecture, de tri et d'impression du tableau. Ce laboratoire propose une approche pratique pour comprendre et appliquer les techniques d'analyse statistique en C.

Lecture et tri du tableau

Dans cette étape, vous apprendrez à lire un tableau de nombres et à le trier en vue du calcul de la médiane. Nous utiliserons le langage C pour accomplir cette tâche.

Tout d'abord, créons un fichier C pour implémenter la lecture et le tri du tableau :

cd ~/project
nano median_calculator.c

Maintenant, ajoutez le code suivant au fichier :

#include <stdio.h>

#define MAX_SIZE 100

// Fonction pour lire les éléments du tableau
void readArray(int arr[], int *n) {
    printf("Entrez le nombre d'éléments (max %d) : ", MAX_SIZE);
    scanf("%d", n);

    printf("Entrez %d éléments :\n", *n);
    for (int i = 0; i < *n; i++) {
        scanf("%d", &arr[i]);
    }
}

// Fonction pour trier le tableau en utilisant le tri à bulles
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]) {
                // Échanger les éléments
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// Fonction pour afficher le tableau
void printArray(int arr[], int n) {
    printf("Tableau trié : ");
    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;
}

Compilez et exécutez le programme :

gcc median_calculator.c -o median_calculator
./median_calculator

Exemple de sortie :

Entrez le nombre d'éléments (max 100) : 5
Entrez 5 éléments :
42
15
7
23
11
Tableau trié : 7 11 15 23 42

Décomposons le code :

1. La fonction readArray() permet à l'utilisateur d'entrer les éléments du tableau.
2. La fonction sortArray() utilise l'algorithme de tri à bulles pour organiser les éléments par ordre croissant.
3. La fonction printArray() affiche le tableau trié.
4. La fonction main() relie ces fonctions.

L'algorithme de tri à bulles a une complexité temporelle de O(n²), ce qui est simple à comprendre mais pas le plus efficace pour les grands ensembles de données.

Calculer l'élément du milieu ou la moyenne des deux éléments du milieu

Dans cette étape, vous étendrez le programme précédent pour calculer la médiane en trouvant l'élément du milieu ou la moyenne des deux éléments du milieu dans un tableau trié.

Ouvrez le fichier existant et modifiez le code :

cd ~/project
nano median_calculator.c

Mettez à jour le code avec une nouvelle fonction pour calculer la médiane :

#include <stdio.h>

#define MAX_SIZE 100

// Les fonctions précédentes (readArray, sortArray, printArray) restent les mêmes

// Nouvelle fonction pour calculer la médiane
float calculateMedian(int arr[], int n) {
    // Si le nombre d'éléments est impair, renvoyer l'élément du milieu
    if (n % 2 != 0) {
        return arr[n / 2];
    }

    // Si le nombre d'éléments est pair, renvoyer la moyenne des deux éléments du milieu
    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);

    // Calculer et afficher la médiane
    float median = calculateMedian(arr, n);
    printf("Médiane : %.2f\n", median);

    return 0;
}

Compilez et exécutez le programme mis à jour :

gcc median_calculator.c -o median_calculator
./median_calculator

Exemple de sortie pour un nombre impair d'éléments :

Entrez le nombre d'éléments (max 100) : 5
Entrez 5 éléments :
42
15
7
23
11
Tableau trié : 7 11 15 23 42
Médiane : 15.00

Exemple de sortie pour un nombre pair d'éléments :

Entrez le nombre d'éléments (max 100) : 6
Entrez 6 éléments :
42
15
7
23
11
8
Tableau trié : 7 8 11 15 23 42
Médiane : 13.00

Points clés sur le calcul de la médiane :

1. Pour un nombre impair d'éléments, la médiane est l'élément du milieu.
2. Pour un nombre pair d'éléments, la médiane est la moyenne des deux éléments du milieu.
3. Le tableau doit être trié avant de calculer la médiane.

La fonction calculateMedian() gère les deux cas :

• Utilise la division entière pour trouver l'index du milieu.
• Vérifie si le nombre d'éléments est impair ou pair.
• Renvoie la valeur de la médiane appropriée.

Affichage de la Médiane

Dans cette dernière étape, vous améliorerez le programme de calcul de la médiane pour fournir une sortie plus détaillée et démontrer différentes manières de présenter la médiane.

Ouvrez le fichier existant pour effectuer les modifications finales :

cd ~/project
nano median_calculator.c

Mettez à jour le code avec une mise en forme de sortie améliorée :

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

#define MAX_SIZE 100

// Les fonctions précédentes (readArray, sortArray, printArray, calculateMedian) restent les mêmes

void printDetailedMedianInfo(int arr[], int n, float median) {
    printf("\n--- Détails du calcul de la médiane ---\n");
    printf("Nombre total d'éléments : %d\n", n);
    printf("Éléments du tableau : ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n\nCalcul de la médiane :\n");

    if (n % 2 != 0) {
        printf("Nombre impair d'éléments\n");
        printf("Index du milieu : %d\n", n / 2);
        printf("Élément du milieu : %d\n", arr[n / 2]);
    } else {
        printf("Nombre pair d'éléments\n");
        printf("Deux indices du milieu : %d et %d\n", (n / 2) - 1, n / 2);
        printf("Éléments du milieu : %d et %d\n", arr[(n / 2) - 1], arr[n / 2]);
    }

    printf("\nMédiane finale : %.2f\n", median);
}

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

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

    float median = calculateMedian(arr, n);

    // Afficher le tableau trié
    printArray(arr, n);

    // Afficher les informations détaillées sur la médiane
    printDetailedMedianInfo(arr, n, median);

    return 0;
}

Compilez et exécutez le programme mis à jour :

gcc median_calculator.c -o median_calculator
./median_calculator

Exemple de sortie pour un nombre impair d'éléments :

Entrez le nombre d'éléments (max 100) : 5
Entrez 5 éléments :
42
15
7
23
11
Tableau trié : 7 11 15 23 42

--- Détails du calcul de la médiane ---
Nombre total d'éléments : 5
Éléments du tableau : 7 11 15 23 42

Calcul de la médiane :
Nombre impair d'éléments
Index du milieu : 2
Élément du milieu : 15

Médiane finale : 15.00

Exemple de sortie pour un nombre pair d'éléments :

Entrez le nombre d'éléments (max 100) : 6
Entrez 6 éléments :
42
15
7
23
11
8
Tableau trié : 7 8 11 15 23 42

--- Détails du calcul de la médiane ---
Nombre total d'éléments : 6
Éléments du tableau : 7 8 11 15 23 42

Calcul de la médiane :
Nombre pair d'éléments
Deux indices du milieu : 2 et 3
Éléments du milieu : 11 et 15

Médiane finale : 13.00

Améliorations clés de cette étape :

1. Ajout d'une nouvelle fonction printDetailedMedianInfo().
2. Fournit des informations complètes sur le calcul de la médiane.
3. Affiche différents scénarios pour un nombre impair et pair d'éléments.
4. Améliore la compréhension de l'utilisateur du calcul de la médiane.

Résumé

Dans ce laboratoire, vous avez appris à lire un tableau de nombres, à les trier à l'aide de l'algorithme de tri à bulles et à préparer les données pour calculer la médiane. Le tableau trié est ensuite affiché à la console, démontrant la réussite de la première étape. L'algorithme de tri à bulles, bien qu'il soit simple à comprendre, a une complexité temporelle de O(n²), ce qui peut ne pas être le plus efficace pour les grands ensembles de données. Les étapes suivantes se concentreront sur la recherche de la médiane du tableau trié.

L'étape suivante consiste à identifier l'élément du milieu ou la moyenne des deux éléments du milieu, en fonction de la taille du tableau. Cette étape garantira que la médiane est calculée et présentée à l'utilisateur avec précision.