Les Tableaux en C : Exercices Corrigés

Les tableaux en C sont une structure de données essentielle permettant de stocker une collection d’éléments du même type en mémoire. Ils sont largement utilisés pour organiser des données linéaires telles que des listes, des vecteurs ou des séquences d’éléments. Cet article explore en détail le concept des tableaux en C, en fournissant des explications théoriques suivies de plusieurs exercices corrigés pour renforcer la compréhension.

1. Définition et Déclaration des Tableaux

Un tableau en C est un bloc contigu de mémoire où sont stockées des variables du même type. Chaque élément du tableau peut être accédé à l’aide d’un indice (ou index) qui commence toujours par 0.

Syntaxe de déclaration :

type nom_tableau[taille];

type : le type des éléments du tableau (par exemple, int, float, char).
nom_tableau : le nom que vous souhaitez donner au tableau.
taille : le nombre d’éléments que le tableau peut contenir.

Exemple :

int tableau[5];

Ici, tableau est un tableau de 5 entiers.

2. Initialisation des Tableaux

Un tableau peut être initialisé lors de sa déclaration. Si le nombre d’éléments fournis est inférieur à la taille du tableau, les éléments restants seront initialisés à 0.

Exemples :

int tableau[5] = {1, 2, 3, 4, 5};
int tableau_partiel[5] = {1, 2}; // Les éléments restants seront 0

3. Accès aux Éléments du Tableau

Chaque élément du tableau est accédé en utilisant un indice :

tableau[0] = 10; // Assigne 10 au premier élément
int x = tableau[2]; // x prend la valeur du troisième élément

4. Parcourir un Tableau

Le parcours d’un tableau est souvent effectué à l’aide d’une boucle for :

for(int i = 0; i < 5; i++) {
    printf("%d ", tableau[i]);
}

5. Exercices Corrigés

Exercice 1 : Trouver le Maximum d’un Tableau

Énoncé : Écrire un programme en C pour trouver le plus grand élément dans un tableau d’entiers.

Solution :

#include <stdio.h>

int main() {
    int tableau[] = {10, 20, 30, 25, 15};
    int max = tableau[0];
    int taille = sizeof(tableau) / sizeof(tableau[0]);

    for(int i = 1; i < taille; i++) {
        if(tableau[i] > max) {
            max = tableau[i];
        }
    }

    printf("Le maximum est : %d\n", max);
    return 0;
}

Explication : On initialise max avec le premier élément du tableau, puis on parcourt les éléments restants pour mettre à jour max si un élément plus grand est trouvé.

Exercice 2 : Inverser un Tableau

Énoncé : Écrire un programme en C pour inverser les éléments d’un tableau.

Solution :

#include <stdio.h>

int main() {
    int tableau[] = {1, 2, 3, 4, 5};
    int taille = sizeof(tableau) / sizeof(tableau[0]);

    for(int i = 0; i < taille / 2; i++) {
        int temp = tableau[i];
        tableau[i] = tableau[taille - i - 1];
        tableau[taille - i - 1] = temp;
    }

    printf("Tableau inversé : ");
    for(int i = 0; i < taille; i++) {
        printf("%d ", tableau[i]);
    }
    printf("\n");
    return 0;
}

Explication : Le programme utilise une boucle pour échanger les éléments symétriques du tableau, de sorte que le premier devient le dernier, le second devient l’avant-dernier, et ainsi de suite.

Exercice 3 : Calculer la Somme des Éléments d’un Tableau

Énoncé : Écrire un programme en C pour calculer la somme de tous les éléments d’un tableau d’entiers.

Solution :

#include <stdio.h>

int main() {
    int tableau[] = {1, 2, 3, 4, 5};
    int taille = sizeof(tableau) / sizeof(tableau[0]);
    int somme = 0;

    for(int i = 0; i < taille; i++) {
        somme += tableau[i];
    }

    printf("La somme des éléments est : %d\n", somme);
    return 0;
}

Explication : Le programme parcourt chaque élément du tableau et ajoute sa valeur à la variable somme.

6. Conclusion

Les tableaux sont une structure de données fondamentale en C, et leur maîtrise est cruciale pour tout programmeur. Grâce aux exercices corrigés présentés, vous devriez maintenant avoir une meilleure compréhension de la manière de manipuler les tableaux pour résoudre des problèmes courants. Pour aller plus loin, vous pouvez explorer les tableaux multidimensionnels, les pointeurs et la gestion dynamique des tableaux.

7. Exercices Supplémentaires

Pour approfondir vos compétences, essayez de résoudre les exercices suivants :

Exercice 4 : Trouver la moyenne des éléments d’un tableau.
Exercice 5 : Trier un tableau en ordre croissant.
Exercice 6 : Rechercher un élément dans un tableau (recherche linéaire).

Chacun de ces exercices renforce des concepts clés liés à la manipulation des tableaux en C.

Voici les exercices demandés avec leurs solutions détaillées :

Exercice 4 : Trouver la Moyenne des Éléments d’un Tableau

Énoncé : Écrire un programme en C qui calcule la moyenne des éléments d’un tableau d’entiers.

Détail : Le programme doit parcourir le tableau pour additionner tous les éléments, puis diviser cette somme par le nombre total d’éléments pour obtenir la moyenne.

Solution :

#include <stdio.h>

int main() {
    int tableau[] = {10, 20, 30, 40, 50};
    int taille = sizeof(tableau) / sizeof(tableau[0]);
    int somme = 0;
    float moyenne;

    // Calcul de la somme des éléments
    for(int i = 0; i < taille; i++) {
        somme += tableau[i];
    }

    // Calcul de la moyenne
    moyenne = (float)somme / taille;

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

    return 0;
}

Explication : Le programme parcourt le tableau pour calculer la somme de tous les éléments, puis divise cette somme par le nombre d’éléments pour obtenir la moyenne. Le résultat est affiché avec deux décimales.

Exercice 5 : Trier un Tableau en Ordre Croissant

Énoncé : Écrire un programme en C qui trie un tableau d’entiers en ordre croissant.

Détail : Le programme doit utiliser l’algorithme de tri à bulles (ou un autre algorithme de tri simple) pour réorganiser les éléments du tableau dans l’ordre croissant.

Solution :

#include <stdio.h>

int main() {
    int tableau[] = {5, 3, 8, 4, 2};
    int taille = sizeof(tableau) / sizeof(tableau[0]);
    int temp;

    // Algorithme de tri à bulles
    for(int i = 0; i < taille - 1; i++) {
        for(int j = 0; j < taille - i - 1; j++) {
            if(tableau[j] > tableau[j + 1]) {
                // Échange des éléments
                temp = tableau[j];
                tableau[j] = tableau[j + 1];
                tableau[j + 1] = temp;
            }
        }
    }

    // Affichage du tableau trié
    printf("Tableau trié en ordre croissant : ");
    for(int i = 0; i < taille; i++) {
        printf("%d ", tableau[i]);
    }
    printf("\n");

    return 0;
}

Explication : Le programme utilise l’algorithme de tri à bulles pour comparer chaque paire d’éléments adjacents du tableau et les échanger si nécessaire, jusqu’à ce que le tableau soit entièrement trié en ordre croissant.

Ces exercices permettent de pratiquer des opérations fondamentales sur les tableaux, comme le calcul de la moyenne et le tri, tout en renforçant les compétences de programmation en C.

Voici quelques exercices particuliers sur les tableaux en C, accompagnés de leur solution détaillée. Ces exercices sont conçus pour mettre en pratique des concepts spécifiques et approfondir votre compréhension.

Suppression d’un Élément dans un Tableau

Énoncé : Écrire un programme en C qui supprime un élément spécifique d’un tableau d’entiers et décale les éléments restants pour combler l’espace laissé.

Détail : Le programme doit demander à l’utilisateur de saisir la position de l’élément à supprimer et afficher le tableau après suppression.

Solution :

#include <stdio.h>

int main() {
    int tableau[] = {1, 2, 3, 4, 5};
    int taille = sizeof(tableau) / sizeof(tableau[0]);
    int position;

    printf("Entrez la position de l'élément à supprimer (1 à %d) : ", taille);
    scanf("%d", &position);

    if(position < 1 || position > taille) {
        printf("Position invalide.\n");
        return 1;
    }

    // Décaler les éléments vers la gauche à partir de la position
    for(int i = position - 1; i < taille - 1; i++) {
        tableau[i] = tableau[i + 1];
    }

    taille--; // Réduire la taille du tableau

    printf("Tableau après suppression : ");
    for(int i = 0; i < taille; i++) {
        printf("%d ", tableau[i]);
    }
    printf("\n");

    return 0;
}

Explication : Le programme décale les éléments du tableau vers la gauche à partir de la position spécifiée par l’utilisateur, puis il réduit la taille logique du tableau.

Insertion d’un Élément dans un Tableau

Énoncé : Écrire un programme en C qui insère un nouvel élément à une position donnée dans un tableau d’entiers.

Détail : Le programme doit demander à l’utilisateur de saisir la position d’insertion ainsi que la valeur à insérer. Le tableau doit être agrandi si nécessaire.

Solution :

#include <stdio.h>

int main() {
    int tableau[6] = {1, 2, 3, 4, 5};
    int taille = 5;
    int position, valeur;

    printf("Entrez la position d'insertion (1 à %d) : ", taille + 1);
    scanf("%d", &position);
    printf("Entrez la valeur à insérer : ");
    scanf("%d", &valeur);

    if(position < 1 || position > taille + 1) {
        printf("Position invalide.\n");
        return 1;
    }

    // Décaler les éléments vers la droite
    for(int i = taille; i >= position; i--) {
        tableau[i] = tableau[i - 1];
    }

    tableau[position - 1] = valeur;
    taille++; // Augmenter la taille logique du tableau

    printf("Tableau après insertion : ");
    for(int i = 0; i < taille; i++) {
        printf("%d ", tableau[i]);
    }
    printf("\n");

    return 0;
}

Explication : Le programme déplace les éléments du tableau vers la droite à partir de la position donnée pour faire de la place à la nouvelle valeur, puis il met à jour la taille du tableau.

Fusion de Deux Tableaux

Énoncé : Écrire un programme en C qui fusionne deux tableaux d’entiers en un seul tableau.

Détail : Le programme doit prendre deux tableaux, les fusionner et afficher le tableau fusionné.

Solution :

#include <stdio.h>

int main() {
    int tableau1[] = {1, 2, 3};
    int tableau2[] = {4, 5, 6, 7};
    int taille1 = sizeof(tableau1) / sizeof(tableau1[0]);
    int taille2 = sizeof(tableau2) / sizeof(tableau2[0]);
    int tableau_fusion[7];

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

    for(int i = 0; i < taille2; i++) {
        tableau_fusion[taille1 + i] = tableau2[i];
    }

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

    return 0;
}

Explication : Le programme copie d’abord les éléments du premier tableau, puis ceux du deuxième tableau, dans un tableau de taille suffisante pour contenir tous les éléments.

Trouver les Nombres Pairs et Impairs

Énoncé : Écrire un programme en C qui sépare les nombres pairs et impairs d’un tableau d’entiers dans deux tableaux distincts.

Détail : Le programme doit parcourir un tableau d’entiers, identifier les nombres pairs et impairs, et les stocker dans deux tableaux différents.

Solution :

#include <stdio.h>

int main() {
    int tableau[] = {1, 2, 3, 4, 5, 6, 7, 8};
    int taille = sizeof(tableau) / sizeof(tableau[0]);
    int pairs[8], impairs[8];
    int index_pair = 0, index_impair = 0;

    for(int i = 0; i < taille; i++) {
        if(tableau[i] % 2 == 0) {
            pairs[index_pair++] = tableau[i];
        } else {
            impairs[index_impair++] = tableau[i];
        }
    }

    printf("Nombres pairs : ");
    for(int i = 0; i < index_pair; i++) {
        printf("%d ", pairs[i]);
    }
    printf("\n");

    printf("Nombres impairs : ");
    for(int i = 0; i < index_impair; i++) {
        printf("%d ", impairs[i]);
    }
    printf("\n");

    return 0;
}

Explication : Le programme utilise deux tableaux pour stocker les nombres pairs et impairs respectivement, en parcourant le tableau d’origine et en triant les éléments selon leur parité.

Détection des Duplicatas dans un Tableau

Énoncé : Écrire un programme en C qui identifie et affiche les éléments en double dans un tableau d’entiers.

Détail : Le programme doit parcourir le tableau et détecter tout élément qui apparaît plus d’une fois.

Solution :

#include <stdio.h>

int main() {
    int tableau[] = {1, 2, 3, 2, 4, 5, 3, 6, 7};
    int taille = sizeof(tableau) / sizeof(tableau[0]);
    int duplicata[taille];
    int index_duplicata = 0;

    for(int i = 0; i < taille; i++) {
        for(int j = i + 1; j < taille; j++) {
            if(tableau[i] == tableau[j]) {
                // Vérifie si ce duplicata a déjà été ajouté
                int deja_ajoute = 0;
                for(int k = 0; k < index_duplicata; k++) {
                    if(duplicata[k] == tableau[i]) {
                        deja_ajoute = 1;
                        break;
                    }
                }
                if(!deja_ajoute) {
                    duplicata[index_duplicata++] = tableau[i];
                }
            }
        }
    }

    printf("Éléments en double : ");
    for(int i = 0; i < index_duplicata; i++) {
        printf("%d ", duplicata[i]);
    }
    printf("\n");

    return 0;
}

Explication : Le programme parcourt chaque paire d’éléments du tableau pour identifier les doublons, puis il les stocke dans un tableau séparé en évitant les doublons dans cette liste.

Ces exercices vous aideront à approfondir vos compétences en manipulation de tableaux en C, tout en abordant des situations pratiques qui peuvent survenir dans des scénarios réels.