Les algorithmes sur tableaux en langage C permettent de rechercher, classer, compter, comparer ou transformer une série de valeurs. Ils constituent une base essentielle de l’algorithmique et préparent à l’étude des pointeurs, des structures de données, de la complexité et de l’optimisation des programmes.

1. Rechercher une valeur dans un tableau

La recherche séquentielle parcourt le tableau case par case jusqu’à trouver la valeur recherchée.

#include <stdio.h>

int rechercher(const int tab[], int taille, int valeur)
{
    for (int i = 0; i < taille; i++)
    {
        if (tab[i] == valeur)
        {
            return i;
        }
    }

    return -1;
}

int main(void)
{
    int tab[] = {12, 7, 25, 18, 9};
    int taille = sizeof(tab) / sizeof(tab[0]);
    int position = rechercher(tab, taille, 18);

    if (position != -1)
    {
        printf("Valeur trouvee a l'indice %d\n", position);
    }
    else
    {
        printf("Valeur absente\n");
    }

    return 0;
}

Dans le pire des cas, le programme examine toutes les cases du tableau. Sa complexité est donc O(n).

2. Recherche dichotomique

La recherche dichotomique fonctionne uniquement sur un tableau déjà trié. Elle divise la zone de recherche par deux à chaque étape.

int rechercheDichotomique(const int tab[], int taille, int valeur)
{
    int gauche = 0;
    int droite = taille - 1;

    while (gauche <= droite)
    {
        int milieu = gauche + (droite - gauche) / 2;

        if (tab[milieu] == valeur)
        {
            return milieu;
        }

        if (tab[milieu] < valeur)
        {
            gauche = milieu + 1;
        }
        else
        {
            droite = milieu - 1;
        }
    }

    return -1;
}

Sa complexité est O(log n), ce qui la rend nettement plus rapide sur les grands tableaux triés.

3. Trouver le minimum et le maximum

int minimum(const int tab[], int taille)
{
    int min = tab[0];

    for (int i = 1; i < taille; i++)
    {
        if (tab[i] < min)
        {
            min = tab[i];
        }
    }

    return min;
}

int maximum(const int tab[], int taille)
{
    int max = tab[0];

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

    return max;
}

4. Inverser un tableau

L’inversion échange la première valeur avec la dernière, la deuxième avec l’avant-dernière, puis continue jusqu’au centre.

void inverser(int tab[], int taille)
{
    int gauche = 0;
    int droite = taille - 1;

    while (gauche < droite)
    {
        int temp = tab[gauche];
        tab[gauche] = tab[droite];
        tab[droite] = temp;

        gauche++;
        droite--;
    }
}

5. Tri à bulles

Le tri à bulles compare les valeurs voisines et les échange lorsqu’elles sont dans le mauvais ordre. Il est simple à comprendre, mais peu performant sur de grands tableaux.

void triBulles(int tab[], int taille)
{
    for (int i = 0; i < taille - 1; i++)
    {
        int echange = 0;

        for (int j = 0; j < taille - 1 - i; j++)
        {
            if (tab[j] > tab[j + 1])
            {
                int temp = tab[j];
                tab[j] = tab[j + 1];
                tab[j + 1] = temp;
                echange = 1;
            }
        }

        if (!echange)
        {
            break;
        }
    }
}

6. Tri par sélection

Le tri par sélection recherche la plus petite valeur dans la partie non triée, puis la place à la position correcte.

void triSelection(int tab[], int taille)
{
    for (int i = 0; i < taille - 1; i++)
    {
        int indiceMin = i;

        for (int j = i + 1; j < taille; j++)
        {
            if (tab[j] < tab[indiceMin])
            {
                indiceMin = j;
            }
        }

        if (indiceMin != i)
        {
            int temp = tab[i];
            tab[i] = tab[indiceMin];
            tab[indiceMin] = temp;
        }
    }
}

7. Tri par insertion

Le tri par insertion construit progressivement une partie triée du tableau. Il est particulièrement efficace sur les petits tableaux ou les tableaux presque triés.

void triInsertion(int tab[], int taille)
{
    for (int i = 1; i < taille; i++)
    {
        int valeur = tab[i];
        int j = i - 1;

        while (j >= 0 && tab[j] > valeur)
        {
            tab[j + 1] = tab[j];
            j--;
        }

        tab[j + 1] = valeur;
    }
}

8. Supprimer les doublons d’un tableau trié

int supprimerDoublons(int tab[], int taille)
{
    if (taille == 0)
    {
        return 0;
    }

    int nouvelleTaille = 1;

    for (int i = 1; i < taille; i++)
    {
        if (tab[i] != tab[nouvelleTaille - 1])
        {
            tab[nouvelleTaille] = tab[i];
            nouvelleTaille++;
        }
    }

    return nouvelleTaille;
}

Cette méthode suppose que le tableau est déjà trié. Les valeurs identiques sont alors voisines.

9. Fusionner deux tableaux triés

void fusionner(const int a[], int tailleA,
               const int b[], int tailleB,
               int resultat[])
{
    int i = 0;
    int j = 0;
    int k = 0;

    while (i < tailleA && j < tailleB)
    {
        if (a[i] <= b[j])
        {
            resultat[k++] = a[i++];
        }
        else
        {
            resultat[k++] = b[j++];
        }
    }

    while (i < tailleA)
    {
        resultat[k++] = a[i++];
    }

    while (j < tailleB)
    {
        resultat[k++] = b[j++];
    }
}

10. Compter les occurrences d’une valeur

int compterOccurrences(const int tab[], int taille, int valeur)
{
    int compteur = 0;

    for (int i = 0; i < taille; i++)
    {
        if (tab[i] == valeur)
        {
            compteur++;
        }
    }

    return compteur;
}

11. Décaler les éléments vers la droite

void decalageDroite(int tab[], int taille)
{
    if (taille <= 1)
    {
        return;
    }

    int dernier = tab[taille - 1];

    for (int i = taille - 1; i > 0; i--)
    {
        tab[i] = tab[i - 1];
    }

    tab[0] = dernier;
}

12. Exemple complet : trier puis rechercher

#include <stdio.h>

void triInsertion(int tab[], int taille)
{
    for (int i = 1; i < taille; i++)
    {
        int valeur = tab[i];
        int j = i - 1;

        while (j >= 0 && tab[j] > valeur)
        {
            tab[j + 1] = tab[j];
            j--;
        }

        tab[j + 1] = valeur;
    }
}

int rechercheDichotomique(const int tab[], int taille, int valeur)
{
    int gauche = 0;
    int droite = taille - 1;

    while (gauche <= droite)
    {
        int milieu = gauche + (droite - gauche) / 2;

        if (tab[milieu] == valeur)
        {
            return milieu;
        }

        if (tab[milieu] < valeur)
        {
            gauche = milieu + 1;
        }
        else
        {
            droite = milieu - 1;
        }
    }

    return -1;
}

int main(void)
{
    int tab[] = {34, 12, 7, 45, 19, 28};
    int taille = sizeof(tab) / sizeof(tab[0]);

    triInsertion(tab, taille);

    int position = rechercheDichotomique(tab, taille, 19);

    printf("Position de 19 : %d\n", position);

    return 0;
}

13. Erreurs fréquentes

• Utiliser une recherche dichotomique sur un tableau non trié.
• Dépasser la dernière case avec une condition de boucle incorrecte.
• Oublier de conserver une valeur temporaire lors d’un échange.
• Confondre indice et valeur.
• Calculer incorrectement le milieu d’une zone de recherche.
• Supprimer des doublons sans mettre à jour la taille logique.
• Comparer des algorithmes sans tenir compte de la taille du tableau.
• Trier un tableau alors qu’une seule recherche séquentielle suffisait.

14. Exercices d’entraînement

#include <stdio.h>

int main(void)
{
    int tab[5];

    for (int i = 0; i < 5; i++)
    {
        printf("Valeur %d : ", i + 1);
        scanf("%d", &tab[i]);
    }

    printf("Tableau : ");

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

    return 0;
}

#include <stdio.h>

int main(void)
{
    int tab[] = {4, 8, 12, 3, 7};
    int taille = sizeof(tab) / sizeof(tab[0]);
    int somme = 0;

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

    printf("Somme : %d\n", somme);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int tab[] = {10, 14, 8, 16, 12};
    int taille = sizeof(tab) / sizeof(tab[0]);
    int somme = 0;

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

    double moyenne = (double)somme / taille;

    printf("Moyenne : %.2f\n", moyenne);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int tab[] = {18, 7, 25, 4, 11};
    int taille = sizeof(tab) / sizeof(tab[0]);
    int minimum = tab[0];

    for (int i = 1; i < taille; i++)
    {
        if (tab[i] < minimum)
        {
            minimum = tab[i];
        }
    }

    printf("Minimum : %d\n", minimum);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int tab[] = {5, 29, 13, 42, 17};
    int taille = sizeof(tab) / sizeof(tab[0]);
    int indiceMax = 0;

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

    printf("Maximum : %d\n", tab[indiceMax]);
    printf("Indice : %d\n", indiceMax);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int tab[] = {4, 7, 10, 13, 18, 21};
    int taille = sizeof(tab) / sizeof(tab[0]);
    int compteur = 0;

    for (int i = 0; i < taille; i++)
    {
        if (tab[i] % 2 == 0)
        {
            compteur++;
        }
    }

    printf("Nombres pairs : %d\n", compteur);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int tab[] = {2, 4, 6, 8, 10};
    int taille = sizeof(tab) / sizeof(tab[0]);

    for (int i = taille - 1; i >= 0; i--)
    {
        printf("%d ", tab[i]);
    }

    return 0;
}

#include <stdio.h>

int main(void)
{
    int source[] = {3, 6, 9, 12, 15};
    int copie[5];
    int taille = sizeof(source) / sizeof(source[0]);

    for (int i = 0; i < taille; i++)
    {
        copie[i] = source[i];
    }

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

    return 0;
}

#include <stdio.h>

int main(void)
{
    int tab[] = {8, 14, 3, 21, 14, 9};
    int taille = sizeof(tab) / sizeof(tab[0]);
    int valeur;
    int position = -1;

    printf("Valeur recherchee : ");
    scanf("%d", &valeur);

    for (int i = 0; i < taille; i++)
    {
        if (tab[i] == valeur)
        {
            position = i;
            break;
        }
    }

    printf("Position : %d\n", position);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int tab[] = {4, 7, 4, 9, 4, 12};
    int taille = sizeof(tab) / sizeof(tab[0]);
    int valeur = 4;
    int occurrences = 0;

    for (int i = 0; i < taille; i++)
    {
        if (tab[i] == valeur)
        {
            occurrences++;
        }
    }

    printf("Occurrences de %d : %d\n", valeur, occurrences);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int tab[] = {2, 5, 8, 11};
    int taille = sizeof(tab) / sizeof(tab[0]);

    for (int i = 0; i < taille; i++)
    {
        *(tab + i) *= 2;
    }

    for (int i = 0; i < taille; i++)
    {
        printf("%d ", *(tab + i));
    }

    return 0;
}

#include <stdio.h>

int main(void)
{
    char texte[] = "programmation";
    int longueur = 0;

    while (texte[longueur] != '\0')
    {
        longueur++;
    }

    printf("Longueur : %d\n", longueur);

    return 0;
}

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    char texte[] = "Langage C";
    int voyelles = 0;

    for (int i = 0; texte[i] != '\0'; i++)
    {
        char c = (char)tolower((unsigned char)texte[i]);

        if (c == 'a' || c == 'e' || c == 'i' ||
            c == 'o' || c == 'u' || c == 'y')
        {
            voyelles++;
        }
    }

    printf("Voyelles : %d\n", voyelles);

    return 0;
}

#include <stdio.h>

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

    int somme = 0;

    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            somme += matrice[i][j];
        }
    }

    printf("Somme : %d\n", somme);

    return 0;
}

#include <stdio.h>

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

    int somme = 0;

    for (int i = 0; i < 3; i++)
    {
        somme += matrice[i][i];
    }

    printf("Somme diagonale : %d\n", somme);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int a[2][2] = {
        {1, 2},
        {3, 4}
    };

    int b[2][2] = {
        {5, 6},
        {7, 8}
    };

    int resultat[2][2];

    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            resultat[i][j] = a[i][j] + b[i][j];
        }
    }

    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            printf("%d ", resultat[i][j]);
        }

        printf("\n");
    }

    return 0;
}

#include <stdio.h>

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

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

    inverser(tab, taille);

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

    return 0;
}

#include <stdio.h>

void triBulles(int tab[], int taille)
{
    for (int i = 0; i < taille - 1; i++)
    {
        for (int j = 0; j < taille - 1 - i; j++)
        {
            if (tab[j] > tab[j + 1])
            {
                int temp = tab[j];
                tab[j] = tab[j + 1];
                tab[j + 1] = temp;
            }
        }
    }
}

int main(void)
{
    int tab[] = {14, 3, 27, 8, 19};
    int taille = sizeof(tab) / sizeof(tab[0]);

    triBulles(tab, taille);

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

    return 0;
}

#include <stdio.h>

int rechercheDichotomique(const int tab[], int taille, int valeur)
{
    int gauche = 0;
    int droite = taille - 1;

    while (gauche <= droite)
    {
        int milieu = gauche + (droite - gauche) / 2;

        if (tab[milieu] == valeur)
        {
            return milieu;
        }

        if (tab[milieu] < valeur)
        {
            gauche = milieu + 1;
        }
        else
        {
            droite = milieu - 1;
        }
    }

    return -1;
}

int main(void)
{
    int tab[] = {2, 5, 8, 12, 18, 25, 31};
    int taille = sizeof(tab) / sizeof(tab[0]);

    printf("Indice : %d\n",
           rechercheDichotomique(tab, taille, 18));

    return 0;
}

#include <stdio.h>

int main(void)
{
    int matrice[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    int transposee[3][2];

    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            transposee[j][i] = matrice[i][j];
        }
    }

    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            printf("%d ", transposee[i][j]);
        }

        printf("\n");
    }

    return 0;
}

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

int main(void)
{
    int taille;
    int somme = 0;

    printf("Taille : ");
    scanf("%d", &taille);

    if (taille <= 0)
    {
        return 1;
    }

    int *tab = malloc((size_t)taille * sizeof(*tab));

    if (tab == NULL)
    {
        return 1;
    }

    for (int i = 0; i < taille; i++)
    {
        scanf("%d", &tab[i]);
        somme += tab[i];
    }

    printf("Somme : %d\n", somme);

    free(tab);
    tab = NULL;

    return 0;
}

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

int main(void)
{
    int taille = 3;
    int *tab = malloc((size_t)taille * sizeof(*tab));

    if (tab == NULL)
    {
        return 1;
    }

    tab[0] = 10;
    tab[1] = 20;
    tab[2] = 30;

    int nouvelleTaille = 5;
    int *temp = realloc(tab,
                        (size_t)nouvelleTaille * sizeof(*tab));

    if (temp == NULL)
    {
        free(tab);
        return 1;
    }

    tab = temp;
    tab[3] = 40;
    tab[4] = 50;

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

    free(tab);

    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void)
{
    char mot[50];
    int palindrome = 1;

    printf("Mot : ");
    scanf("%49s", mot);

    size_t longueur = strlen(mot);

    for (size_t i = 0; i < longueur / 2; i++)
    {
        if (mot[i] != mot[longueur - 1 - i])
        {
            palindrome = 0;
            break;
        }
    }

    if (palindrome)
    {
        printf("Palindrome\n");
    }
    else
    {
        printf("Pas un palindrome\n");
    }

    return 0;
}

#include <stdio.h>

int supprimerDoublons(int tab[], int taille)
{
    if (taille == 0)
    {
        return 0;
    }

    int nouvelleTaille = 1;

    for (int i = 1; i < taille; i++)
    {
        if (tab[i] != tab[nouvelleTaille - 1])
        {
            tab[nouvelleTaille] = tab[i];
            nouvelleTaille++;
        }
    }

    return nouvelleTaille;
}

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

    taille = supprimerDoublons(tab, taille);

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

    return 0;
}

#include <stdio.h>

void fusionner(const int a[], int tailleA,
               const int b[], int tailleB,
               int resultat[])
{
    int i = 0;
    int j = 0;
    int k = 0;

    while (i < tailleA && j < tailleB)
    {
        if (a[i] <= b[j])
        {
            resultat[k++] = a[i++];
        }
        else
        {
            resultat[k++] = b[j++];
        }
    }

    while (i < tailleA)
    {
        resultat[k++] = a[i++];
    }

    while (j < tailleB)
    {
        resultat[k++] = b[j++];
    }
}

int main(void)
{
    int a[] = {1, 4, 7, 10};
    int b[] = {2, 3, 8, 12, 15};
    int resultat[9];

    fusionner(a, 4, b, 5, resultat);

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

    return 0;
}

#include <stdio.h>

int main(void)
{
    int a[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    int b[3][2] = {
        {7, 8},
        {9, 10},
        {11, 12}
    };

    int resultat[2][2] = {0};

    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            for (int k = 0; k < 3; k++)
            {
                resultat[i][j] += a[i][k] * b[k][j];
            }
        }
    }

    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            printf("%d ", resultat[i][j]);
        }

        printf("\n");
    }

    return 0;
}

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

int main(void)
{
    int lignes;
    int colonnes;

    printf("Lignes et colonnes : ");
    scanf("%d %d", &lignes, &colonnes);

    if (lignes <= 0 || colonnes <= 0)
    {
        return 1;
    }

    int **matrice = malloc((size_t)lignes *
                           sizeof(*matrice));

    if (matrice == NULL)
    {
        return 1;
    }

    for (int i = 0; i < lignes; i++)
    {
        matrice[i] = malloc((size_t)colonnes *
                            sizeof(*matrice[i]));

        if (matrice[i] == NULL)
        {
            for (int k = 0; k < i; k++)
            {
                free(matrice[k]);
            }

            free(matrice);
            return 1;
        }
    }

    for (int i = 0; i < lignes; i++)
    {
        for (int j = 0; j < colonnes; j++)
        {
            matrice[i][j] = i + j;
            printf("%d ", matrice[i][j]);
        }

        printf("\n");
    }

    for (int i = 0; i < lignes; i++)
    {
        free(matrice[i]);
    }

    free(matrice);

    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void)
{
    char villes[5][30] = {
        "Toulouse",
        "Paris",
        "Lyon",
        "Marseille",
        "Bordeaux"
    };

    char temporaire[30];

    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4 - i; j++)
        {
            if (strcmp(villes[j], villes[j + 1]) > 0)
            {
                strcpy(temporaire, villes[j]);
                strcpy(villes[j], villes[j + 1]);
                strcpy(villes[j + 1], temporaire);
            }
        }
    }

    for (int i = 0; i < 5; i++)
    {
        printf("%s\n", villes[i]);
    }

    return 0;
}

#include <stdio.h>
#include <limits.h>

int main(void)
{
    int tab[] = {14, 9, 32, 18, 32, 27};
    int taille = sizeof(tab) / sizeof(tab[0]);

    int maximum = INT_MIN;
    int deuxieme = INT_MIN;

    for (int i = 0; i < taille; i++)
    {
        if (tab[i] > maximum)
        {
            deuxieme = maximum;
            maximum = tab[i];
        }
        else if (tab[i] > deuxieme &&
                 tab[i] != maximum)
        {
            deuxieme = tab[i];
        }
    }

    if (deuxieme == INT_MIN)
    {
        printf("Aucune deuxieme valeur distincte.\n");
    }
    else
    {
        printf("Deuxieme maximum : %d\n", deuxieme);
    }

    return 0;
}

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

double calculerMoyenne(const double notes[], int taille)
{
    double somme = 0.0;

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

    return somme / taille;
}

double trouverMaximum(const double notes[], int taille)
{
    double maximum = notes[0];

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

    return maximum;
}

void trierDecroissant(double notes[], int taille)
{
    for (int i = 0; i < taille - 1; i++)
    {
        for (int j = 0; j < taille - 1 - i; j++)
        {
            if (notes[j] < notes[j + 1])
            {
                double temp = notes[j];
                notes[j] = notes[j + 1];
                notes[j + 1] = temp;
            }
        }
    }
}

int main(void)
{
    int nombreEleves;

    printf("Nombre d'eleves : ");
    scanf("%d", &nombreEleves);

    if (nombreEleves <= 0)
    {
        return 1;
    }

    double *notes = malloc((size_t)nombreEleves *
                           sizeof(*notes));

    if (notes == NULL)
    {
        return 1;
    }

    for (int i = 0; i < nombreEleves; i++)
    {
        do
        {
            printf("Note de l'eleve %d : ", i + 1);
            scanf("%lf", &notes[i]);
        }
        while (notes[i] < 0.0 || notes[i] > 20.0);
    }

    printf("Moyenne : %.2f\n",
           calculerMoyenne(notes, nombreEleves));

    printf("Meilleure note : %.2f\n",
           trouverMaximum(notes, nombreEleves));

    trierDecroissant(notes, nombreEleves);

    printf("Classement : ");

    for (int i = 0; i < nombreEleves; i++)
    {
        printf("%.2f ", notes[i]);
    }

    free(notes);
    notes = NULL;

    return 0;
}

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 :

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.

• QCM sur les Tableaux en Langage C
• Tableaux en Langage C : Exercices Corrigés
• Série d’Exercices Corrigés : Manipulation de Tableaux et Chaînes de Caractères
• Tableaux en Langage C : Exercices Corrigés