Recherche des éléments les plus grands et les plus petits d'un tableau en C

CCBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Trouver les éléments les plus grands et les plus petits dans un tableau est un problème courant en programmation que vous rencontrerez fréquemment. Cette compétence est essentielle pour diverses applications, telles que l'analyse de données, le développement de jeux et les algorithmes de tri.

Dans ce laboratoire (LabEx), vous apprendrez à écrire un programme en langage C qui identifie à la fois les éléments les plus grands et les plus petits dans un tableau d'entiers. Nous allons décomposer le processus en étapes claires et gérables pour vous aider à comprendre la logique derrière cette technique de programmation fondamentale.

Finding the largest and smallest elements in an array

Ce laboratoire nécessite des connaissances de base en programmation C, y compris les variables, les tableaux, les boucles et les instructions conditionnelles. À la fin de cette session, vous aurez créé un programme C complet qui montre comment trouver les valeurs extrêmes dans un ensemble de données.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL c(("C")) -.-> c/BasicsGroup(["Basics"]) c(("C")) -.-> c/ControlFlowGroup(["Control Flow"]) c(("C")) -.-> c/CompoundTypesGroup(["Compound Types"]) c(("C")) -.-> c/UserInteractionGroup(["User Interaction"]) c/BasicsGroup -.-> c/variables("Variables") c/BasicsGroup -.-> c/operators("Operators") c/ControlFlowGroup -.-> c/if_else("If...Else") c/ControlFlowGroup -.-> c/for_loop("For Loop") c/CompoundTypesGroup -.-> c/arrays("Arrays") c/UserInteractionGroup -.-> c/user_input("User Input") c/UserInteractionGroup -.-> c/output("Output") subgraph Lab Skills c/variables -.-> lab-123271{{"Recherche des éléments les plus grands et les plus petits d'un tableau en C"}} c/operators -.-> lab-123271{{"Recherche des éléments les plus grands et les plus petits d'un tableau en C"}} c/if_else -.-> lab-123271{{"Recherche des éléments les plus grands et les plus petits d'un tableau en C"}} c/for_loop -.-> lab-123271{{"Recherche des éléments les plus grands et les plus petits d'un tableau en C"}} c/arrays -.-> lab-123271{{"Recherche des éléments les plus grands et les plus petits d'un tableau en C"}} c/user_input -.-> lab-123271{{"Recherche des éléments les plus grands et les plus petits d'un tableau en C"}} c/output -.-> lab-123271{{"Recherche des éléments les plus grands et les plus petits d'un tableau en C"}} end

Configuration de la structure du programme

Commençons par créer un nouveau fichier C et en configurant la structure de base de notre programme. Cela inclura les fichiers d'en-tête nécessaires, la fonction principale (main) et les déclarations de variables.

Tout d'abord, accédez au répertoire du projet et créez un nouveau fichier nommé main.c :

cd ~/project
touch main.c

Maintenant, ouvrez le fichier main.c dans l'éditeur et ajoutez le code suivant :

#include <stdio.h>

int main() {
    // We'll declare an array with a maximum capacity of 50 elements
    int array[50];
    // Variables to store the size of the array and loop counter
    int size, i;
    // Variables to store the largest and smallest elements
    int largest, smallest;

    printf("Finding Largest and Smallest Elements in an Array\n");
    printf("------------------------------------------------\n\n");

    return 0;
}

Ce code configure la structure de base de notre programme. Comprenons ce que chaque partie fait :

  • #include <stdio.h> inclut la bibliothèque standard d'entrée/sortie, qui fournit des fonctions telles que printf() et scanf().
  • La fonction main() est le point d'entrée de notre programme.
  • Nous déclarons un tableau d'entiers nommé array avec une capacité de 50 éléments.
  • La variable size stockera le nombre d'éléments que l'utilisateur souhaite saisir.
  • La variable i sera utilisée comme compteur de boucle.
  • Les variables largest et smallest stockeront les valeurs maximale et minimale trouvées dans le tableau.

Enregistrez le fichier après avoir ajouté ce code. Cela configure les bases de notre programme.

Récupération des entrées de l'utilisateur

Maintenant que la structure de notre programme est prête, ajoutons le code pour obtenir les entrées de l'utilisateur. Nous devons demander à l'utilisateur la taille du tableau, puis collecter les éléments du tableau.

Ouvrez le fichier main.c dans l'éditeur et modifiez-le en ajoutant le code suivant avant l'instruction return 0; :

// Ask user for the size of the array
printf("Enter the size of the array (max 50): ");
scanf("%d", &size);

// Validate the input size
if (size <= 0 || size > 50) {
    printf("Invalid array size. Please enter a size between 1 and 50.\n");
    return 1;
}

// Get array elements from the user
printf("\nEnter %d elements of the array:\n", size);
for (i = 0; i < size; i++) {
    printf("Element %d: ", i + 1);
    scanf("%d", &array[i]);
}

// Display the entered array
printf("\nThe array you entered is: [ ");
for (i = 0; i < size; i++) {
    printf("%d ", array[i]);
}
printf("]\n\n");

Ce code :

  1. Demande à l'utilisateur d'entrer la taille du tableau.
  2. Vérifie que la taille est comprise entre 1 et 50.
  3. Demande à l'utilisateur d'entrer chaque élément du tableau un par un.
  4. Affiche le tableau entré à l'utilisateur pour confirmation.

Compilons et exécutons notre programme pour voir ce que nous avons pour l'instant :

gcc main.c -o main
./main

Vous devriez voir une invite demandant la taille du tableau. Entrez un petit nombre comme 5, puis entrez 5 valeurs. Le programme affichera le tableau que vous avez entré.

Par exemple, si vous entrez 5 pour la taille, puis les valeurs 10, 25, 5, 17 et 9, vous devriez voir la sortie suivante :

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Maintenant que nous avons collecté les éléments du tableau de l'utilisateur, nous pouvons passer à la recherche des valeurs maximale et minimale.

Recherche de l'élément le plus grand

Ajoutons maintenant le code pour trouver l'élément le plus grand dans le tableau. La stratégie est la suivante :

  1. Supposons que le premier élément est le plus grand.
  2. Comparez chaque élément suivant avec le plus grand élément actuel.
  3. Si un élément plus grand est trouvé, mettez à jour la valeur du plus grand élément.

Ajoutez le code suivant à votre fichier main.c, avant l'instruction return 0; :

// Initialize largest with the first element of the array
largest = array[0];

// Find the largest element
printf("Finding the largest element...\n");
for (i = 1; i < size; i++) {
    if (array[i] > largest) {
        largest = array[i];
        printf("New largest found at position %d: %d\n", i + 1, largest);
    }
}

printf("\nThe largest element in the array is: %d\n\n", largest);

Ce code initialise la variable largest avec le premier élément du tableau. Il parcourt ensuite le tableau en commençant par le deuxième élément (indice 1), comparant chaque élément avec la valeur du plus grand élément actuel. Si un élément plus grand est trouvé, il met à jour la variable largest et affiche un message.

Compilons et exécutons notre programme pour voir les résultats :

gcc main.c -o main
./main

Entrez la taille et les éléments du tableau comme précédemment. Par exemple, si vous entrez les valeurs 10, 25, 5, 17 et 9, vous devriez voir une sortie similaire à :

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Finding the largest element...
New largest found at position 2: 25

The largest element in the array is: 25

Cela montre comment notre programme trouve l'élément le plus grand dans le tableau. L'algorithme commence par considérer le premier élément comme le plus grand et le met à jour chaque fois qu'il trouve une valeur plus grande.

Recherche de l'élément le plus petit

Maintenant que nous avons trouvé l'élément le plus grand, ajoutons le code pour trouver l'élément le plus petit dans le tableau. La stratégie est similaire :

  1. Supposons que le premier élément est le plus petit.
  2. Comparez chaque élément suivant avec le plus petit élément actuel.
  3. Si un élément plus petit est trouvé, mettez à jour la valeur du plus petit élément.

Ajoutez le code suivant à votre fichier main.c, avant l'instruction return 0; :

// Initialize smallest with the first element of the array
smallest = array[0];

// Find the smallest element
printf("Finding the smallest element...\n");
for (i = 1; i < size; i++) {
    if (array[i] < smallest) {
        smallest = array[i];
        printf("New smallest found at position %d: %d\n", i + 1, smallest);
    }
}

printf("\nThe smallest element in the array is: %d\n", smallest);

Ce code initialise la variable smallest avec le premier élément du tableau. Il parcourt ensuite le tableau en commençant par le deuxième élément (indice 1), comparant chaque élément avec la valeur du plus petit élément actuel. Si un élément plus petit est trouvé, il met à jour la variable smallest et affiche un message.

Compilons et exécutons notre programme pour voir les résultats complets :

gcc main.c -o main
./main

Entrez la taille et les éléments du tableau comme précédemment. Par exemple, si vous entrez les valeurs 10, 25, 5, 17 et 9, vous devriez voir une sortie similaire à :

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Finding the largest element...
New largest found at position 2: 25

The largest element in the array is: 25

Finding the smallest element...
New smallest found at position 3: 5

The smallest element in the array is: 5

Cela montre comment notre programme trouve à la fois l'élément le plus grand et le plus petit dans le tableau. Les algorithmes commencent par le premier élément et le mettent à jour chaque fois qu'ils trouvent respectivement une valeur plus grande ou plus petite.

Optimisation du programme et code complet

Maintenant que nous avons un programme fonctionnel, optimisons-le en combinant la recherche à la fois de l'élément le plus grand et du plus petit dans une seule boucle. Cela est plus efficace car nous n'avons besoin de parcourir le tableau qu'une seule fois au lieu de deux.

Ouvrez le fichier main.c et remplacez tout le contenu par la version optimisée suivante :

#include <stdio.h>

int main() {
    // We'll declare an array with a maximum capacity of 50 elements
    int array[50];
    // Variables to store the size of the array and loop counter
    int size, i;
    // Variables to store the largest and smallest elements
    int largest, smallest;

    printf("Finding Largest and Smallest Elements in an Array\n");
    printf("------------------------------------------------\n\n");

    // Ask user for the size of the array
    printf("Enter the size of the array (max 50): ");
    scanf("%d", &size);

    // Validate the input size
    if (size <= 0 || size > 50) {
        printf("Invalid array size. Please enter a size between 1 and 50.\n");
        return 1;
    }

    // Get array elements from the user
    printf("\nEnter %d elements of the array:\n", size);
    for (i = 0; i < size; i++) {
        printf("Element %d: ", i + 1);
        scanf("%d", &array[i]);
    }

    // Display the entered array
    printf("\nThe array you entered is: [ ");
    for (i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("]\n\n");

    // Initialize largest and smallest with the first element
    largest = smallest = array[0];

    // Find both the largest and smallest elements in a single pass
    printf("Searching for largest and smallest elements...\n");
    for (i = 1; i < size; i++) {
        // Check for largest
        if (array[i] > largest) {
            largest = array[i];
            printf("New largest found at position %d: %d\n", i + 1, largest);
        }

        // Check for smallest
        if (array[i] < smallest) {
            smallest = array[i];
            printf("New smallest found at position %d: %d\n", i + 1, smallest);
        }
    }

    // Display results
    printf("\nResults:\n");
    printf("- The largest element in the array is: %d\n", largest);
    printf("- The smallest element in the array is: %d\n", smallest);

    // Calculate and display the range
    printf("- The range (difference between largest and smallest) is: %d\n", largest - smallest);

    return 0;
}

Cette version optimisée :

  1. Utilise une seule boucle pour trouver à la fois l'élément le plus grand et le plus petit, rendant le programme plus efficace.
  2. Initialise à la fois largest et smallest au premier élément du tableau.
  3. Ajoute un calcul de l'étendue (la différence entre les valeurs maximale et minimale).

Compilons et exécutons notre programme optimisé :

gcc main.c -o main
./main

Entrez la taille et les éléments du tableau comme précédemment. Par exemple, si vous entrez les valeurs 10, 25, 5, 17 et 9, vous devriez voir une sortie similaire à :

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Searching for largest and smallest elements...
New largest found at position 2: 25
New smallest found at position 3: 5

Results:
- The largest element in the array is: 25
- The smallest element in the array is: 5
- The range (difference between largest and smallest) is: 20

Cette version optimisée fournit les mêmes résultats qu'avant mais est plus efficace et inclut des informations supplémentaires sur l'étendue des valeurs.

Lorsque vous travaillez avec de grands tableaux, ces améliorations d'efficacité peuvent réduire considérablement le temps de calcul, ce qui est une considération importante en programmation.

Résumé

Dans ce laboratoire, vous avez créé avec succès un programme en langage C qui trouve à la fois l'élément le plus grand et le plus petit dans un tableau. Revoyons ce que vous avez appris :

  1. Vous avez mis en place une structure de programme de base avec les déclarations de variables nécessaires.
  2. Vous avez écrit le code pour obtenir les entrées de l'utilisateur concernant la taille et les éléments du tableau.
  3. Vous avez implémenté un algorithme pour trouver l'élément le plus grand dans le tableau.
  4. Vous avez implémenté un algorithme similaire pour trouver l'élément le plus petit dans le tableau.
  5. Vous avez optimisé le programme en combinant les deux recherches dans une seule boucle et ajouté des fonctionnalités supplémentaires.

Ce laboratoire a couvert plusieurs concepts de programmation fondamentaux :

  • Les tableaux (arrays) et le parcours de tableaux
  • L'utilisation de boucles pour l'itération
  • Les instructions conditionnelles
  • L'optimisation d'algorithmes
  • L'obtention et la validation des entrées de l'utilisateur

Ces compétences sont essentielles pour tout programmeur et constituent la base pour des structures de données et des algorithmes plus complexes. La capacité à trouver les valeurs extrêmes dans un ensemble de données est une exigence courante dans de nombreux scénarios de programmation, comme la recherche des scores élevés dans les jeux, l'analyse des mesures de température ou le traitement des données financières.

Vous pouvez étendre ce programme en ajoutant des fonctionnalités telles que :

  • Le calcul de la moyenne de tous les éléments du tableau
  • Le tri du tableau
  • La recherche de la valeur médiane
  • Le comptage des occurrences de valeurs spécifiques

Continuez à pratiquer ces concepts pour renforcer vos compétences en programmation.