NSI 1ère

Tableaux unidimensionnels
Exercices corrigés

Maîtrisez les tableaux unidimensionnels : déclaration, accès, manipulation, algorithmes de base grâce à ces 5 exercices détaillés.

Concepts & Exercices
\(\text{Tableau}[i] = \text{valeur}\)
Accès à un élément
Déclaration
tab[10]: entier
Création
Accès
tab[0]
Lecture
Affectation
tab[0] ← 5
Écriture
📊
Tableau : Structure de données qui stocke plusieurs éléments du même type.
🔢
Indices : Numéros qui permettent d'accéder aux éléments (généralement de 0 à n-1).
🎯
Accès : O(1) - Accès direct à n'importe quel élément par son indice.
Exercice 1
Déclarer et initialiser un tableau d'entiers
Exercice 2
Accéder et modifier des éléments d'un tableau
Exercice 3
Calculer la somme des éléments d'un tableau
Exercice 4
Trouver le maximum et le minimum d'un tableau
Exercice 5
Trier un tableau dans l'ordre croissant
Corrigé : Exercices 1 à 3
1 Déclaration et initialisation
Définition :

Tableau unidimensionnel : Structure de données qui stocke une séquence d'éléments du même type dans des cases consécutives en mémoire.

Méthode de déclaration :
  1. Déclarer le tableau avec un type et une taille fixe
  2. Spécifier le nombre d'éléments
  3. Initialiser les éléments (optionnel)
  4. Accéder aux éléments par leur indice
// Déclaration d'un tableau de 5 entiers VARIABLES notes[5] : ENTIER VARIABLES i : ENTIER // Initialisation manuelle notes[0] ← 12 notes[1] ← 15 notes[2] ← 8 notes[3] ← 18 notes[4] ← 14 // Initialisation dans une boucle POUR i DE 0 À 4 FAIRE notes[i] ← i * 2 FIN POUR // Initialisation directe (selon le langage) VARIABLES tab[4] : ENTIER ← [10, 20, 30, 40]
┌─────┬─────┬─────┬─────┬─────┐
│ 0 │ 1 │ 2 │ 3 │ 4 │ ← Indices
├─────┼─────┼─────┼─────┼─────┤
│ 12 │ 15 │ 8 │ 18 │ 14 │ ← Valeurs
└─────┴─────┴─────┴─────┴─────┘
Tableau "notes" de 5 éléments
Étape 1 : Déclarer le tableau

Spécifier le type des éléments et la taille du tableau

Étape 2 : Accéder aux éléments

Utiliser des indices de 0 à n-1 (si n est la taille)

Étape 3 : Initialiser les valeurs

Affecter des valeurs à chaque case du tableau

Résultat :

Tableau déclaré et initialisé avec des valeurs accessibles par indice

Règles appliquées :

• Indices : Commencent à 0 et vont jusqu'à taille-1

• Homogénéité : Tous les éléments sont du même type

• Accès : Direct par l'indice en temps constant O(1)

2 Accès et modification
Définition :

Accès aux éléments : Opération qui permet de lire ou modifier la valeur d'un élément à un indice donné.

Opération Syntaxe Exemple Lecture tableau[indice] valeur ← tab[2] Écriture tableau[indice] ← valeur tab[2] ← 15 Parcours POUR i DE 0 À n-1 BOUCLE pour accéder à tous
VARIABLES temperatures[7] : REEL VARIABLES i, somme : ENTIER VARIABLES moyenne : REEL // Initialisation temperatures[0] ← 18.5 temperatures[1] ← 20.0 temperatures[2] ← 22.3 temperatures[3] ← 19.8 temperatures[4] ← 21.1 temperatures[5] ← 23.5 temperatures[6] ← 20.9 // Lecture d'un élément ECRIRE("Température du mercredi:", temperatures[2]) // Modification d'un élément temperatures[2] ← 22.5 // Correction de la température // Accès dans une boucle somme ← 0 POUR i DE 0 À 6 FAIRE somme ← somme + temperatures[i] FIN POUR moyenne ← somme / 7
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ ← Indices
├─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│18.5 │ 20.0│ 22.5│ 19.8│ 21.1│ 23.5│ 20.9│ ← Valeurs
└─────┴─────┴─────┴─────┴─────┴─────┴─────┘
Tableau "temperatures" après modification de l'indice 2
Étape 1 : Lire un élément

Utiliser l'indice pour accéder à la valeur : temperatures[2]

Étape 2 : Modifier un élément

Affecter une nouvelle valeur à l'indice : temperatures[2] ← 22.5

Étape 3 : Parcourir le tableau

Utiliser une boucle pour accéder à tous les éléments

Résultat :

Capacité à lire et modifier n'importe quel élément du tableau

Règles appliquées :

• Accès direct : O(1) - temps constant pour accéder à un élément

• Indices valides : Vérifier que l'indice est dans les bornes

• Modification : Peut être faite directement par affectation

3 Somme des éléments
Définition :

Somme d'un tableau : Calcul de la somme de tous les éléments en parcourant le tableau avec une boucle.

FONCTION sommeTableau(tab[] : ENTIER, taille : ENTIER) : ENTIER DEBUT VARIABLES i, resultat : ENTIER resultat ← 0 POUR i DE 0 À taille-1 FAIRE resultat ← resultat + tab[i] FIN POUR RETOURNER resultat FIN
i tab[i] resultat avant resultat après 0 10 0 10 1 20 10 30 2 30 30 60 3 40 60 100
Étape 1 : Initialiser l'accumulateur

Créer une variable resultat initialisée à 0

Étape 2 : Parcourir le tableau

Utiliser une boucle pour accéder à chaque élément

Étape 3 : Accumuler les valeurs

Additionner chaque élément à l'accumulateur

Résultat :

La fonction retourne la somme de tous les éléments du tableau

Règles appliquées :

• Initialisation : Toujours initialiser l'accumulateur à 0

• Parcours complet : Visiter tous les éléments du tableau

• Accumulation : Ajouter chaque élément à l'accumulateur

Corrigé : Exercices 4 à 5
4 Maximum et minimum
Définition :

Maximum/minimum : Algorithmes qui trouvent la plus grande ou la plus petite valeur dans un tableau.

FONCTION trouverMaximum(tab[] : ENTIER, taille : ENTIER) : ENTIER DEBUT VARIABLES i, max : ENTIER SI taille = 0 ALORS RETOURNER 0 // ou lever une erreur FIN SI max ← tab[0] // Initialiser avec premier élément POUR i DE 1 À taille-1 FAIRE SI tab[i] > max ALORS max ← tab[i] FIN SI FIN POUR RETOURNER max FIN FONCTION trouverMinimum(tab[] : ENTIER, taille : ENTIER) : ENTIER DEBUT VARIABLES i, min : ENTIER SI taille = 0 ALORS RETOURNER 0 // ou lever une erreur FIN SI min ← tab[0] // Initialiser avec premier élément POUR i DE 1 À taille-1 FAIRE SI tab[i] < min ALORS min ← tab[i] FIN SI FIN POUR RETOURNER min FIN
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ ← Indices
├─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│ 5 │ 12 │ 3 │ 18 │ 7 │ 1 │ 15 │ ← Valeurs
└─────┴─────┴─────┴─────┴─────┴─────┴─────┘
Maximum: 18 (indice 3), Minimum: 1 (indice 5)
Étape 1 : Initialiser avec le premier élément

Prendre tab[0] comme valeur de référence

Étape 2 : Parcourir le reste du tableau

Commencer à l'indice 1 pour comparer avec la référence

Étape 3 : Mettre à jour la valeur extrême

Remplacer la valeur si un nouvel extremum est trouvé

Résultat :

Algorithmes qui trouvent le maximum et le minimum en O(n) opérations

Règles appliquées :

• Initialisation : Commencer avec le premier élément

• Comparaison : Comparer chaque élément avec l'extrémum actuel

• Mise à jour : Remplacer l'extrémum quand un meilleur est trouvé

5 Tri du tableau
Définition :

Tri par sélection : Algorithme qui trie un tableau en trouvant successivement le minimum et en le plaçant au début.

PROCEDURE triSelection(tab[] : ENTIER, taille : ENTIER) DEBUT VARIABLES i, j, minIndex, temp : ENTIER POUR i DE 0 À taille-2 FAIRE minIndex ← i // Supposer que le minimum est à l'indice i // Trouver le véritable minimum dans le reste du tableau POUR j DE i+1 À taille-1 FAIRE SI tab[j] < tab[minIndex] ALORS minIndex ← j FIN SI FIN POUR // Échanger l'élément à i avec le minimum trouvé SI minIndex ≠ i ALORS temp ← tab[i] tab[i] ← tab[minIndex] tab[minIndex] ← temp FIN SI FIN POUR FIN
Étape Tableau avant Min trouvé Tableau après 0 [64, 25, 12, 22, 11] 11 à pos 4 [11, 25, 12, 22, 64] 1 [11, 25, 12, 22, 64] 12 à pos 2 [11, 12, 25, 22, 64] 2 [11, 12, 25, 22, 64] 22 à pos 3 [11, 12, 22, 25, 64] 3 [11, 12, 22, 25, 64] 25 à pos 3 [11, 12, 22, 25, 64]
Étape 1 : Parcourir le tableau

Pour chaque position i, chercher le minimum dans le reste

Étape 2 : Trouver le minimum

Parcourir les éléments de i+1 à n-1 pour trouver le plus petit

Étape 3 : Échanger

Placer le minimum trouvé à la position i

Résultat :

Tableau trié dans l'ordre croissant en O(n²) opérations

Règles appliquées :

• Itération : Pour chaque position, placer l'élément correct

• Recherche : Trouver le minimum dans la partie non triée

• Échange : Intervertir les éléments pour placer le minimum

Cours bien détaillé
\(\text{Tab}[i] = \text{valeur}, \text{ où } 0 \leq i < n\)
Accès aux éléments
🎯
Définition : Un tableau unidimensionnel est une structure de données qui stocke une séquence d'éléments du même type.
📏
Objectif : Permettre le stockage et la manipulation de plusieurs valeurs sous un seul nom.
📐
Caractéristiques : Taille fixe, accès direct par indice, éléments homogènes.
📝
Applications : Statistiques, tris, recherche, manipulation de données.
💡
Conseil : Toujours vérifier les bornes avant d'accéder à un élément
🔍
Attention : Les indices commencent à 0 dans la plupart des langages
⚡
Astuce : Utilisez des constantes pour les tailles de tableaux
📋
Méthode : Initialisez toujours les tableaux avant utilisation
✅
Vérification : Testez vos algorithmes avec des cas limites
Algorithmes classiques :
  • Somme : Parcours avec accumulateur
  • Recherche : Parcours avec condition
  • Maximum/Minimum : Comparaison successive
  • Tri : Sélection, insertion, bulle
  • Inversion : Échange d'éléments symétriques
Règles importantes :
  • La taille d'un tableau est fixe une fois déclaré
  • Les indices commencent à 0 et vont jusqu'à taille-1
  • Un accès hors bornes provoque une erreur
  • Les éléments sont du même type dans un tableau homogène
  • L'accès direct par indice est en temps constant O(1)
Tableaux unidimensionnels Structures de données simples