Tableaux en Langage C : Exercices Corrigés

Voici une série d’exercices corrigés sur les tableaux en langage C, allant des bases aux concepts plus avancés. Ces exercices vous aideront à mieux comprendre la manipulation des tableaux et les opérations associées.

Exercice 1 : Remplir un tableau et afficher ses éléments

Énoncé :

Écrivez un programme en C qui remplit un tableau de 5 entiers donnés par l’utilisateur et affiche ensuite les éléments du tableau.

Correction :

#include <stdio.h>

int main() {
    int tableau[5];

    // Saisie des éléments du tableau
    for(int i = 0; i < 5; i++) {
        printf("Entrez l'élément %d : ", i + 1);
        scanf("%d", &tableau[i]);
    }

    // Affichage des éléments du tableau
    printf("Les éléments du tableau sont :\n");
    for(int i = 0; i < 5; i++) {
        printf("%d ", tableau[i]);
    }
    printf("\n");

    return 0;
}

Explication :

Le tableau tableau[5] est utilisé pour stocker 5 entiers.
Une boucle for remplit le tableau avec les entrées de l’utilisateur.
Une deuxième boucle for affiche les éléments du tableau.

Exercice 2 : Trouver la valeur maximale d’un tableau

Énoncé :

Écrivez un programme en C qui demande à l’utilisateur de remplir un tableau de 10 entiers, puis trouve et affiche la valeur maximale dans ce tableau.

Correction :

#include <stdio.h>

int main() {
    int tableau[10];
    int max;

    // Saisie des éléments du tableau
    for (int i = 0; i < 10; i++) {
        printf("Entrez l'élément %d : ", i + 1);
        scanf("%d", &tableau[i]);
    }

    // Initialisation de la variable max avec le premier élément du tableau
    max = tableau[0];

    // Recherche du maximum
    for (int i = 1; i < 10; i++) {
        if (tableau[i] > max) {
            max = tableau[i];
        }
    }

    // Affichage du maximum
    printf("La valeur maximale est : %d\n", max);

    return 0;
}

Explication :

Le programme initialise la variable max avec le premier élément du tableau.
Ensuite, une boucle parcourt les autres éléments du tableau pour trouver le plus grand élément.

Exercice 3 : Calcul de la moyenne d’un tableau

Énoncé :

Écrivez un programme en C qui lit 5 nombres flottants, les stocke dans un tableau, et affiche ensuite la moyenne de ces nombres.

Correction :

#include <stdio.h>

int main() {
    float tableau[5], somme = 0.0, moyenne;

    // Saisie des éléments du tableau
    for(int i = 0; i < 5; i++) {
        printf("Entrez l'élément %d : ", i + 1);
        scanf("%f", &tableau[i]);
        somme += tableau[i];  // Ajouter chaque élément à la somme
    }

    // Calcul de la moyenne
    moyenne = somme / 5;

    // Affichage de la moyenne
    printf("La moyenne des éléments est : %.2f\n", moyenne);

    return 0;
}

Explication :

Le tableau tableau[5] contient des nombres flottants.
À chaque itération, les éléments sont ajoutés à la somme, et à la fin, la moyenne est calculée en divisant la somme par 5.

Exercice 4 : Inverser les éléments d’un tableau

Énoncé :

Écrivez un programme en C qui lit 6 entiers, les stocke dans un tableau, puis affiche les éléments dans l’ordre inverse.

Correction :

#include <stdio.h>

int main() {
    int tableau[6];

    // Saisie des éléments du tableau
    for(int i = 0; i < 6; i++) {
        printf("Entrez l'élément %d : ", i + 1);
        scanf("%d", &tableau[i]);
    }

    // Affichage des éléments dans l'ordre inverse
    printf("Les éléments du tableau dans l'ordre inverse sont :\n");
    for(int i = 5; i >= 0; i--) {
        printf("%d ", tableau[i]);
    }
    printf("\n");

    return 0;
}

Explication :

Le programme lit 6 entiers dans un tableau.
Ensuite, une boucle for inverse les éléments en commençant par le dernier et en affichant chaque élément.

Exercice 5 : Tri d’un tableau (Tri par sélection)

Énoncé :

Écrivez un programme en C qui lit 5 entiers, les stocke dans un tableau, puis les trie dans l’ordre croissant en utilisant l’algorithme du tri par sélection.

Correction :

#include <stdio.h>

int main() {
    int tableau[5], i, j, min, temp;

    // Saisie des éléments du tableau
    for(i = 0; i < 5; i++) {
        printf("Entrez l'élément %d : ", i + 1);
        scanf("%d", &tableau[i]);
    }

    // Tri par sélection
    for(i = 0; i < 4; i++) {
        min = i;
        for(j = i + 1; j < 5; j++) {
            if(tableau[j] < tableau[min]) {
                min = j;
            }
        }
        // Échange des éléments
        temp = tableau[min];
        tableau[min] = tableau[i];
        tableau[i] = temp;
    }

    // Affichage du tableau trié
    printf("Le tableau trié est :\n");
    for(i = 0; i < 5; i++) {
        printf("%d ", tableau[i]);
    }
    printf("\n");

    return 0;
}

Explication :

Le programme utilise l’algorithme du tri par sélection pour trier un tableau de 5 entiers.
À chaque itération, il trouve l’élément minimum dans la partie non triée du tableau et le place à la position correcte en l’échangeant avec l’élément actuel.

Exercice 6 : Fusionner deux tableaux

Énoncé :

Écrivez un programme en C qui lit deux tableaux de 5 entiers chacun, puis les fusionne dans un troisième tableau.

Correction :

#include <stdio.h>

int main() {
    int tableau1[5], tableau2[5], tableau_fusion[10];

    // Saisie des éléments du premier tableau
    printf("Entrez les éléments du premier tableau :\n");
    for(int i = 0; i < 5; i++) {
        scanf("%d", &tableau1[i]);
    }

    // Saisie des éléments du deuxième tableau
    printf("Entrez les éléments du deuxième tableau :\n");
    for(int i = 0; i < 5; i++) {
        scanf("%d", &tableau2[i]);
    }

    // Fusion des deux tableaux
    for(int i = 0; i < 5; i++) {
        tableau_fusion[i] = tableau1[i];
        tableau_fusion[i + 5] = tableau2[i];
    }

    // Affichage du tableau fusionné
    printf("Le tableau fusionné est :\n");
    for(int i = 0; i < 10; i++) {
        printf("%d ", tableau_fusion[i]);
    }
    printf("\n");

    return 0;
}

Explication :

Le programme fusionne les éléments des deux tableaux de 5 entiers dans un troisième tableau de 10 entiers.
Le premier tableau est copié dans la première moitié du tableau fusionné, et le deuxième tableau est copié dans la deuxième moitié.

Ces exercices tableaux en langage C vous permettent de pratiquer les bases et des concepts légèrement plus avancés liés aux tableaux en C. Vous pouvez essayer d’autres variantes, comme implémenter des algorithmes de tri plus complexes ou travailler sur des tableaux dynamiques.

Fiche de Rappel : Les Tableaux en Langage C

Les tableaux en C sont des structures de données qui permettent de stocker plusieurs éléments du même type dans un bloc de mémoire contigu. Ils sont particulièrement utiles lorsque vous devez manipuler une collection d’éléments, comme des nombres ou des chaînes de caractères.

1. Déclaration d’un tableau en C

Pour déclarer un tableau, il suffit de spécifier le type des éléments, le nom du tableau, et le nombre d’éléments à stocker dans ce tableau.

Syntaxe :

type nom_du_tableau[taille];

Exemple :

int tableau_entiers[10];  // Tableau de 10 entiers
float tableau_flottants[5];  // Tableau de 5 nombres flottants
char tableau_caracteres[20];  // Tableau de 20 caractères

Indice : Les tableaux en C sont indexés à partir de 0. Le premier élément d’un tableau se trouve à l’indice 0, le deuxième à l’indice 1, et ainsi de suite.

2. Initialisation d’un tableau

Un tableau peut être initialisé au moment de sa déclaration en spécifiant les valeurs à l’intérieur d’accolades {}.

Exemple d’initialisation :

int tableau[5] = {1, 2, 3, 4, 5};  // Tableau initialisé avec 5 valeurs

Si vous ne spécifiez pas le nombre d’éléments, le compilateur allouera automatiquement l’espace nécessaire pour toutes les valeurs spécifiées.

int tableau[] = {1, 2, 3, 4, 5};  // Taille déduite automatiquement

3. Accès aux éléments du tableau

L’accès aux éléments d’un tableau se fait en utilisant son indice.

Exemple :

int tableau[5] = {10, 20, 30, 40, 50};
printf("%d\n", tableau[0]);  // Affiche 10
printf("%d\n", tableau[4]);  // Affiche 50

Modification d’un élément :

tableau[2] = 100;  // Change la valeur à l'indice 2 en 100

4. Parcours d’un tableau

Pour parcourir un tableau, on utilise généralement une boucle for ou while.

Exemple avec `for` :

int tableau[5] = {10, 20, 30, 40, 50};
for (int i = 0; i < 5; i++) {
    printf("%d ", tableau[i]);  // Affiche les éléments du tableau
}

5. Tableaux multidimensionnels

En C, vous pouvez déclarer des tableaux à plusieurs dimensions (comme les matrices). Un tableau à 2 dimensions est similaire à une matrice, où les éléments sont organisés en lignes et en colonnes.

Déclaration :

type nom_du_tableau[taille1][taille2];

Exemple de tableau 2D (matrice) :

int matrice[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

Accès à un élément d’une matrice :

printf("%d\n", matrice[0][1]);  // Affiche 2

6. Tableaux de chaînes de caractères

Un tableau de caractères (ou chaîne de caractères) est un tableau d’éléments de type char.

Exemple :

char nom[10] = "Alice";  // Chaîne de caractères

Dans ce cas, le tableau contient les caractères 'A', 'l', 'i', 'c', 'e' suivis d’un caractère nul (\0), qui marque la fin de la chaîne.

Tableau de chaînes :

Vous pouvez créer un tableau de chaînes de caractères pour stocker plusieurs mots ou phrases.

char noms[3][10] = {"Alice", "Bob", "Charlie"};

7. Passage de tableau en paramètre

En C, lorsqu’un tableau est passé à une fonction, c’est l’adresse de son premier élément qui est transmise (par référence).

Exemple :

void afficher_tableau(int tableau[], int taille) {
    for (int i = 0; i < taille; i++) {
        printf("%d ", tableau[i]);
    }
    printf("\n");
}

int main() {
    int tableau[5] = {1, 2, 3, 4, 5};
    afficher_tableau(tableau, 5);  // Passe le tableau à la fonction
    return 0;
}

8. Mémoire et tableaux

Les tableaux en C occupent de la mémoire contiguë, c’est-à-dire que les éléments sont stockés les uns à la suite des autres.

Taille d’un tableau :

Vous pouvez utiliser l’opérateur sizeof pour obtenir la taille en octets d’un tableau, ou la taille d’un élément.

Exemple :

int tableau[5];
printf("Taille du tableau : %lu octets\n", sizeof(tableau));  // Taille totale en octets
printf("Taille d'un élément : %lu octets\n", sizeof(tableau[0]));  // Taille d'un élément

Pour obtenir le nombre d’éléments :

int taille = sizeof(tableau) / sizeof(tableau[0]);

9. Erreurs fréquentes avec les tableaux

Débordement de tableau : Accéder à un indice qui dépasse la taille du tableau peut entraîner des comportements indéfinis.
Par exemple, essayer d’accéder à tableau[5] alors que le tableau a été déclaré avec 5 éléments (tableau[0] à tableau[4]).
Non-initialisation des tableaux : Si un tableau n’est pas initialisé explicitement, les éléments peuvent contenir des valeurs indéfinies.

Résumé des principales commandes :

Commande	Description
`type nom[taille];`	Déclare un tableau de taille fixe.
`nom[indice] = valeur;`	Modifie la valeur d’un élément du tableau.
`int nom[][] = {{...},{...}}`	Déclare un tableau multidimensionnel.
`sizeof(tableau)`	Renvoie la taille totale en octets d’un tableau.
`nom[indice]`	Accède à l’élément à l’indice spécifié dans le tableau.

En résumé, les tableaux en C sont un moyen efficace de manipuler des collections d’éléments du même type, que ce soit en 1D (tableau simple) ou en 2D (tableau multidimensionnel). Leur gestion requiert de la prudence en ce qui concerne la gestion des indices et la mémoire allouée.