Logique de programmation : manipuler des listes (parcours, recherche, filtrage)

Manipuler des listes : l’essentiel

Une liste est une collection ordonnée d’éléments (ex. produits, tâches, messages, mesures). Manipuler une liste consiste souvent à parcourir ses éléments pour rechercher, filtrer, compter ou calculer une valeur (max/min). L’idée centrale : on lit la liste de gauche à droite et on met à jour des variables (résultat, compteur, meilleur candidat) au fur et à mesure.

Vocabulaire pratique

• Élément : la valeur stockée (ex. "lait").
• Index : la position (souvent à partir de 0) (ex. index 0 = premier élément).
• Longueur : nombre d’éléments de la liste.
• Liste vide : longueur = 0.

Parcours séquentiel : index vs élément

Il existe deux manières courantes de parcourir une liste.

Parcours par élément (le plus simple)

POUR CHAQUE element DANS liste FAIRE    ... utiliser element ...FIN POUR

À utiliser quand on n’a pas besoin de la position, seulement des valeurs.

Parcours par index (quand la position compte)

POUR i DE 0 À longueur(liste)-1 FAIRE    element = liste[i]    ... utiliser i et/ou element ...FIN POUR

À utiliser quand on doit modifier la liste à un index précis, comparer avec un voisin, ou produire un résultat qui dépend de la position.

Longueur, ajout et suppression : opérations courantes

Longueur

n = longueur(liste)

La longueur sert souvent à gérer les cas limites : vide (n=0) ou un seul élément (n=1).

Continuez dans notre application.

Vous pouvez écouter le livre audio écran éteint, recevoir un certificat gratuit pour ce cours et accéder également à 5 000 autres cours en ligne gratuits.

Ou poursuivez votre lecture ci-dessous...

Téléchargez l'application

Ajouter un élément

Deux intentions fréquentes :

• Ajouter à la fin (append) : utile pour construire une liste filtrée.
• Insérer à une position : utile si l’ordre doit être respecté.

ajouter_fin(liste, element)inserer(liste, position, element)

Supprimer un élément

On peut supprimer :

• par valeur (supprimer la première occurrence trouvée),
• par index (supprimer à une position donnée).

supprimer_valeur(liste, element)supprimer_index(liste, position)

Attention : supprimer pendant un parcours par index peut décaler les éléments. Une stratégie simple consiste à construire une nouvelle liste (filtrage) plutôt que de supprimer en place.

Recherche d’un élément : trouver ou confirmer l’absence

Rechercher signifie parcourir jusqu’à trouver l’élément (ou finir la liste). On peut retourner :

• un booléen (trouvé / non trouvé),
• un index (position),
• l’élément lui-même (ou une valeur spéciale si absent).

Recherche avec arrêt anticipé

trouve = FAUXPOUR CHAQUE x DANS liste FAIRE    SI x == cible ALORS        trouve = VRAI        ARRETER LA BOUCLE    FIN SIFIN POURRETOURNER trouve

Le choix d’un parcours unique avec arrêt anticipé évite de lire le reste de la liste une fois la réponse connue.

Filtrage selon un prédicat

Filtrer consiste à conserver uniquement les éléments qui vérifient une règle (un prédicat) : une fonction qui renvoie vrai/faux pour un élément.

resultat = liste_videPOUR CHAQUE x DANS liste FAIRE    SI predicat(x) ALORS        ajouter_fin(resultat, x)    FIN SIFIN POURRETOURNER resultat

On privilégie souvent la construction d’une nouvelle liste : c’est clair, évite les problèmes de suppression en cours de parcours, et reste un parcours unique.

Compter les occurrences

Compter revient à incrémenter un compteur à chaque fois qu’un élément correspond à une cible (ou à une règle).

compteur = 0POUR CHAQUE x DANS liste FAIRE    SI x == cible ALORS        compteur = compteur + 1    FIN SIFIN POURRETOURNER compteur

Exercice 13 — Rechercher un produit dans une liste de courses

Énoncé

On dispose d’une liste de courses (chaînes de caractères). Écrire un algorithme qui indique si un produit donné est présent. Gérer les cas : liste vide, liste à un élément.

Pseudo-code

FONCTION produit_present(liste_courses, produit) -> booleen    SI longueur(liste_courses) == 0 ALORS        RETOURNER FAUX    FIN SI    POUR CHAQUE item DANS liste_courses FAIRE        SI item == produit ALORS            RETOURNER VRAI        FIN SI    FIN POUR    RETOURNER FAUXFIN FONCTION

Pourquoi ce choix ?

Un parcours unique suffit. On retourne immédiatement dès qu’on trouve le produit (arrêt anticipé), ce qui évite des comparaisons inutiles.

Tests (y compris cas limites)

Exercice 14 — Filtrer les tâches “à faire aujourd’hui”

Énoncé

On a une liste de tâches, chaque tâche ayant un nom et une date (ou un indicateur) d’échéance. Produire une nouvelle liste contenant uniquement les tâches à faire aujourd’hui. Gérer les cas : liste vide, liste à un élément.

Représentation simple

On peut représenter une tâche comme un objet/enregistrement : {nom, date}. On suppose qu’on connaît aujourd_hui.

Pseudo-code

FONCTION taches_pour_aujourdhui(liste_taches, aujourd_hui) -> liste    resultat = liste_vide    POUR CHAQUE tache DANS liste_taches FAIRE        SI tache.date == aujourd_hui ALORS            ajouter_fin(resultat, tache)        FIN SI    FIN POUR    RETOURNER resultatFIN FONCTION

Pourquoi ce choix ?

Le filtrage se fait naturellement en un seul parcours en construisant une nouvelle liste. Cela évite de supprimer des éléments dans la liste d’origine (risque de décalage) et rend l’intention très lisible.

Tests (y compris cas limites)

Exercice 15 — Compter les occurrences d’un mot dans une liste de messages

Énoncé

On a une liste de messages (chaînes). Compter combien de messages contiennent exactement un mot cible (cas simple : le message est un mot unique), ou compter combien de fois le mot apparaît si chaque message est déjà un mot. Gérer les cas : liste vide, liste à un élément.

Hypothèse simple (liste de mots)

Pour se concentrer sur la logique de liste, on suppose que chaque élément est un mot (ex. ["ok","urgent","ok"]).

Pseudo-code

FONCTION compter_occurrences(liste_mots, mot_cible) -> entier    compteur = 0    POUR CHAQUE mot DANS liste_mots FAIRE        SI mot == mot_cible ALORS            compteur = compteur + 1        FIN SI    FIN POUR    RETOURNER compteurFIN FONCTION

Pourquoi ce choix ?

Un compteur mis à jour pendant un parcours unique est la solution la plus directe. Le compteur est initialisé à 0, ce qui gère naturellement les listes vides.

Tests (y compris cas limites)

Exercice 16 — Trouver le maximum et le minimum d’une série de mesures

Énoncé

On dispose d’une liste de mesures numériques (températures, poids, distances). Trouver la valeur minimale et la valeur maximale. Gérer les cas : liste vide, liste à un élément.

Point d’attention : initialisation correcte

Pour calculer min et max, il faut une initialisation qui fonctionne pour des valeurs négatives et des listes variées. La stratégie la plus robuste : initialiser min et max avec le premier élément (si la liste n’est pas vide), puis parcourir le reste.

Pseudo-code

FONCTION min_max(mesures) -> (min, max)    SI longueur(mesures) == 0 ALORS        RETOURNER (NUL, NUL)    FIN SI    min = mesures[0]    max = mesures[0]    POUR i DE 1 À longueur(mesures)-1 FAIRE        x = mesures[i]        SI x < min ALORS            min = x        FIN SI        SI x > max ALORS            max = x        FIN SI    FIN POUR    RETOURNER (min, max)FIN FONCTION

Pourquoi ce choix ?

• Parcours unique : on met à jour min et max en une seule lecture.
• Initialisation sûre : prendre le premier élément évite d’utiliser des valeurs arbitraires (comme 0) qui échoueraient si toutes les mesures sont négatives ou si 0 n’est pas pertinent.
• Cas limites : si la liste a un seul élément, min et max restent égaux à cet élément.

Tests (y compris cas limites)