N.S.

I Term
CHAPITRE 3–Structures de données
1 Table des matières
2 Introduction 2
3 L’essentiel 2
3.1 Mes notes 2
4 Rappel types structurés 4
4.1 Exercices maison Canvas 4
5 Type abstrait 4
5.1 Définition 4
5.2 L’interface 4
5.3 Le cas python 4
6 Les listes chaînées 5
6.1 Interface 5
6.2 Implémentation par des tuples 5
6.2.1 Exercices 6
6.3 Implémentation par un tableau 7
6.3.1 Définition 7
6.3.2 Exercices 8
7 Les piles 10
7.1 Présentation 10
7.2 Opérations courantes de l’interface 10
7.3 Implémentation par une liste 10
7.4 Implémentation par un tableau 10
7.4.1 Exercices 10
8 Les files 14
8.1 Présentation 14
8.2 Opération élémentaires avec implémentation tableau 14
8.3 Exercices 15

CHAPITRE 3–Structures de données 1

 N.S.I Term
2 Introduction

La résolution de problème par des programmes informatiques nécessite de biendéfinir les données manipulées par
ces programmes. Pour cela, on utilise destypes abstraits de données adaptés au problème.

En informatique, un type abstrait (en anglais, abstract data type ou ADT) est une manière de décrire de façon précise
(spécifier)un ensemble de données et l'ensemble des opérations qu'on peut effectuer sur elles. On qualifie
d'abstrait ce type de données car il correspond à un cahier des charges qu'une structure de données doit ensuite
mettre en œuvre.

Ce chapitre présente trois types abstraits classiques :les listes, les piles et les files, et montre plusieurs
implémentationsde chacun d'eux.

3 L’essentiel
3.1 Mes notes

……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………

CHAPITRE 3–Structures de données 2

 N.S.I Term
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………

CHAPITRE 3–Structures de données 3

 N.S.I Term
4 Rappel types structurés
4.1 Exercices maison Canvas
Vous devez :

 Répondre à un QCM " Pré-requis structure des données" sur les pré-requis de ce chapitre. Attention il
est primordial de bien regarder la correction et de compléter « mon essentiel ».

 Regarder une vidéo sur les structures de données.Attention il est également primordial de prendre des
notes et de compléter « mon essentiel ».

 Effectuer le TP notebooksur l’écriture de 3 fonctions (elles doivent être spécifiées et testées). Ce TP est
un avant-goût de l’épreuve pratique.

5 Type abstrait
5.1 Définition
Le langage Python dispose, comme tous les langages, d'un ensemble de types de base et de types structurés vus
dans le programme de Première : nombres, chaînes de caractères, tuples, tableaux, dictionnaires. Ces types sont des
briques de base qui permettent de créer des structures de données plus complexes.

Pour définir ces structures de données, on utilise des types abstraits de données. Un type abstrait spécifie :
• Le type de données contenues
• Une description détaillée des opérations qui peuvent être effectuées sur les données

5.2 L’interface
Une structure de données possède un ensemble de routine (procédures ou fonctions) permettant d’ajouter,
d’effacer, d’accéder aux données. Cet ensemble de routines est appelé interface. Les 4 routines élémentaires de
l’interface (CRUD) que constituent les routines sont :

 Creat qui permet de créer une nouvelle structure de données ;

 Read qui permet de lire les données,
 Uptade qui permet de modifier la structure de données,
 Delate qui permet d’effacer des données,
5.3 Le cas python
Python est un langage interprété. Il fait des choix par rapport à des notions algorithmiques.

Typiquement en algorithmique, il existe deux notions de types différents

 Les tableaux : les éléments y sont ordonnés et classé par des numéros de 0 à la taille du tableau - 1
 Les listes : les éléments y sont rangés dans un certain ordre mais l’on a accès qu’à certains éléments. Pour
récupérer les autres il faut enlever les éléments précédents ou suivants.

Python fait donc le choix d’interprétation de fusionner ces deux notions algorithmiques ce qui les rend plus faciles à
manipuler mais qui est l’arbre qui cache la forêt.

Dans ce chapitre nous nous concentrerons sur la notion algorithmique de liste chainée (liste algorithmique) et les
deux sous-notions qui en découlent : celle de pile et celle de file.

CHAPITRE 3–Structures de données 4

 N.S.I Term
6 Les listes chaînées
Une liste est une structure de données permettant de regrouper des données. Une liste L est composée de 2 parties
: sa tête (souvent noté car), qui correspond au dernier élément ajouté à la liste, et sa queue (souvent noté cdr) qui
correspond au reste de la liste.

Le langage de programmation Lisp (inventé par John McCarthy en 1958) a été un des premiers langages de
programmation à introduire cette notion de liste (Lisp signifie "listprocessing").

6.1 Interface
Voici les opérations de l’interface qui peuvent être effectuées sur une liste

 creer_liste() : retourne une liste vide;

 est_liste_ vide(liste): retourne Vrai si la listeest vide;
 inserer(liste, element): insère e en tête de liste et retourne la nouvelle liste;
 tete(liste) : retourne l'élément en tête de liste (si celle-ci n'est pas vide);
 queue(liste): retourne la liste privée de son premier élément (si la liste n'est pas vide) ;

Dans cette structure on peut modifier la liste chainée en enlevant le premier élément et en récupérant la fin de la
liste. Nous avons donc accès seulement au premier élément et pas directement aux suivants

6.2 Implémentation par des tuples

On peut implémenter une liste en Python en utilisant des tuples. Comme les tuples Python sont immuables, la liste
elle-même sera immuable, ce qui peut être intéressant dans certains cas.

Prenons la suite d’instruction suivante :

CHAPITRE 3–Structures de données 5
 N.S.I Term
 Quelle est la valeur de "ma_liste "
 Quelle sont les 3 valeurs de "liste_2 " à chaque étape
 Quelle sont les valeurs de "dernier" et "liste_avant"

……………………………………………………………………………………
ma_liste = creer_liste()
……………………………………………………………………………………
liste_vide(ma_liste)
liste_2 = inserer(ma_liste,12) ……………………………………………………………………………………
liste_2 = inserer(liste_2,15) ……………………………………………………………………………………
liste_2 = inserer(liste_2,11) ……………………………………………………………………………………
dernier = tete(liste_2)
liste_avant = queue(liste_2) ……………………………………………………………………………………
……………………………………………………………………………………
………………………………

……………………………………………………………………………………………………………………………………………………………….
…………………………………………………………………………………………………………………………………………………………………………………….
…………………………………………………………………………………………………………………………………………………………………………………….
…………………………………………………………………………………………………………………………………………………………………………………….
……………………
6.2.1 Exercices
Exercice N°1
Quel pré-condition(assert) devrait-on ajouter à tete(liste) et queue(liste) ?
……………………………………………………………………………………………………………………………………………………………….……………………

Exercice N°2
Quelles sont les valeurs de L1 et L2 à la fin de la suite d’instructions suivantes :

L1 = creer_liste()
L1 = inserer(L1, "Alice")
L2 = inserer(L1, "Bob")
L1 = inserer(L1, "Charlie")

……………………………………………………………………………………………………………………………………………………………….……………………

Exercice N°3
Donner les valeurs de liste1, liste 2 et liste 3 à chaque étape

liste1 liste2 liste3

liste1 = creer_liste()
liste1 = inserer(liste1, 3)
liste1 = inserer(liste1, -1)
liste1 = inserer(liste1, 1)
liste2 = queue(liste1)
liste3 = queue(liste2)
liste3 = inserer(liste3, tete(liste1))

CHAPITRE 3–Structures de données 6

 N.S.I Term
Exercice N°4
Ecrire une fonction ranger(liste_c) qui prend en entrée une liste chainée liste_c codée ave des tuples et qui renvoie
un tableau contenant les éléments de la liste chainée dans le même ordre :
>>> ranger( (3, (1, (2, ()))) )
[3, 1, 2]
>>> ranger( () )
[]
>>> ranger( (2, ()) )
[2]

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………
CHAPITRE 3–Structures de données 7
 N.S.I Term
6.3 Implémentation par un tableau
6.3.1 Définition

Une autre implémentation possible d'une liste consiste à utiliser un tableau. La liste est alors représentée par un
tuple constitué du tableu et du nombre d'éléments de la liste. La représentation de la liste de l'exemple précédent
avec un tableau de taille 5 est alors la suivante :

liste=([ "Alice", "Nourr", "Moussa", None, None],3)

MOUSS
NOURR ALICE
A

Le tableau ayant une taille fixe, il faut prévoir que la capacité de la liste est limitée à la taille du tableau. IL est aussi
possible de créer un tableau plus grand et d'y recopier la liste lorsque nécessaire.
Les tableaux Python sont en réalité des listes puisqu'ils sont extensibles avec la méthode append .

6.3.2 Exercices
Voici les opérations de l’interface qui peuvent être effectuées sur une liste avec une implémentation tableau. Dans le
TP Notebook, vous allez devoir écrire les fonctions suivantes.

 creer_liste(n) : retourne un tuple formé d’un tableau de n éléments et d’une taille 0 ;

 est_liste_vide(liste): retourne Vrai si la liste est vide, Faux sinon;
 inserer(liste, element): insère e en tête de liste et retourne la nouvelle liste, décale tous les éléments du
tableau vers la droite et insère l’élément au rang 1;
 tete(liste) : retourne l'élément en tête de liste (si celle-ci n'est pas vide);
 queue(liste): retourne la liste privée de son premier élément (si la liste n'est pas vide) ;
 On vous demandera de créer de nouvelles fonctions en utilisant ces fonctions que vous aurez construites

Exercice N°5
Ecrire ces fonctions en python :
……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

CHAPITRE 3–Structures de données 8

 N.S.I Term
……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

CHAPITRE 3–Structures de données 9

 N.S.I Term
……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

CHAPITRE 3–Structures de données 10

 N.S.I Term
……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

7 Les piles
7.1 Présentation

CHAPITRE 3–Structures de données 11

 N.S.I Term
On retrouve dans les piles une partie des propriétés vues sur les listes. Dans les piles, il est uniquement possible de
manipuler le dernier élément introduit dans la pile. On prend souvent l'analogie avec une pile d'assiettes : dans une
pile d'assiettes la seule assiette directement accessible et la dernière assiette qui a été déposée sur la pile.

Les piles sont très utilisées sur les plateformes de streaming musical. Lorsque vous
demandez à la plateforme de lire une chanson à la suite, elle va ajouter cette
dernière tout en haut de la liste "en attente de lecture".

Il s’agit d’une structure de données qui donne accès en priorité aux dernières
données ajoutées. Ainsi, la dernière information ajoutée sera la première à en sortir.

Les piles sont ce que l’on appelle un traitement des données LIFO (Last In First
Out, ou dans la langue de Molière : dernier ajouté premier parti).

7.2 Opérations courantes de l’interface

Les opérations courantes appelées primitives de gestion des piles sont :

 creer_pile() : retourne une pile vide;

 est_vide(pile): retourne Vrai si la pile est vide;
 empiler(pile, element): opérateur qui ajoute un élément au sommet de la pile
 depiler(liste) : renvoie l’élément au sommet de la pile et l’enlève de la liste (si la liste n'est pas vide)
 taille(pile): retourne le nombre élément présent dans la pile;

7.3 Implémentation par une liste

Une liste permet d'implémenter une pile de façon quasiment immédiate puisque les opérations insérer () , tête () et
queue () correspondent respectivement à empiler(), sommet() et dépiler() .

7.4 Implémentation par un tableau

Une autre implémentation consiste à utiliser un tableau. De façon similaire à l'implémentation d'une liste par un
tableau, on utilise un tuple contenant le tableau lui-même et le nombre d'éléments dans la pile, qui est aussi l'indice
auquel sera ajouté le prochain élément

7.4.1 Exercices
Exercice N°6
……………………………………………………………………………………
P= creer_pile()
empiler(P,4) ……………………………………………………………………………………
empiler (P,7) ……………………………………………………………………………………
a = depiler(P)
b = taille(P)
c = depiler(P)
empiler(P,3)
empiler(P,2)
d = taille(P)

Donnez le contenu de la pile P, la valeur de a, la valeur

de b, la valeur de c et la valeur de d.

……………………………………………………………………………………
……………………………………………………………………………………
CHAPITRE 3–Structures de données 12
 N.S.I Term
Exercice N°7
pile = creer_pile()
empiler(pile, 4)
empiler (pile, 3)
empiler (pile, 8)
somme = 0
pile2 = créer_pile()
while est_vide(pile) != True :
element = depiler(pile)
somme += element
empiler(pile2, element)

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

CHAPITRE 3–Structures de données 13

 N.S.I Term
……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

Exercice N°8
On considère l’implémentation python des deux fonctions suivante :

def creer_pile_vide():
"""
Créer une pile vide
"""
return []

def est_vide(p):
"""
Renvoie un booleen : True si la pile est vide, False sinon
"""
if p == []:
return True
else:
return False

1. Ecrire une fonction empiler(pile, element) qui rajoute l’élément dans la pile

CHAPITRE 3–Structures de données 14

 N.S.I Term
……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

2. Ecrire une fonction dépiler(pile) qui enlève le dernier élément ajouté dans la pile et retourne cet élément
(cette fonction nécessite une assertion)

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

3. Ecrire une fonction inverse_pile(pile) qui prend en entrée une pile et renvoie une nouvelle pile inversée.

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

Exercice N°9

CHAPITRE 3–Structures de données 15

 N.S.I Term
On considère l’implémentation python de la fonction suivante

def fonction_mystere(p):
" " " L’entrée est une pile " " "
Q = creer_pile_vide()
n = 0
while not(est_vide(p)):
n += 1
x = depiler(p)
empiler(Q, x)
while not(est_vide(Q)):
x = depiler(Q)
empiler(p, x)
return n

1. Tester cette fonction sur la pile [2, 3]

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

2. Tester cette fonction sur la pile [1, 2, 3]

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

CHAPITRE 3–Structures de données 16

 N.S.I Term
3. Que fait cette fonction ?

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

8 Les files
8.1 Présentation

Une file est une structure de données dans laquelle on accède aux éléments
suivant la règle du premier arrivé premier sorti. Autrement dit, on ne peut
accéder qu’à l’objet situé au début de la file. On décrit souvent ce comportement
par l’expression : FIFO (First In, First Out). La file comporte une tête et une queue.

Analogie : La file de clients qui attend à un guichet ou à une caisse convient à cette description. Le client qui
passe le premier est normalement celui qui est arrivé le premier.

8.2 Opération élémentaires avec implémentation tableau

Nous aurions pu implémenter les files avec un tuple constitué d’un tableau et du nombre d’éléments (comme avec
les listes chainées). Pour mémoire, le tableau dans cet exemple avait une taille fixe. Pour les files, nous allons utiliser
la particularité de python, les tableaux ayant une taille non fixée.

Il est nécessaire d’avoir deux pointeurs pour une file. Un pour gérer les entrées en queue et un pour gérer les sorties
en tête. Deux opérations sont particulièrement utiles :

 enfiler(tableau,e)qui correspond à l’insertion de la donnée e à la queue de la file.

 defiler(tableau)qui retire la donnée de tête de la file et la retourne

Tête 0 1 2 3 4 5 6 7
Queue

0 1 2 3 4 5 6 7 Enfiler

Défiler 0 1 2 3 4 5 6 7

def creer_file_vide():

CHAPITRE 3–Structures de données 17

 N.S.I Term
"""Fonction file qui retourne une vide"""
return []

def enfiler(file,element):
"""L'élément est inséré en queue de la file)"""
liste = [None] * (len(file)+1)
for indice in range(len(file)):
liste[indice]=file[indice]
liste[len(file)]=element
return liste

def defiler(file):
"""L'élément situé en tête de la file est enlevé de la file"""
if est_vide(file) != True :
liste = [None] * (len(file)-1)
for indice in range (len(file)-1):
liste[indice] = file[indice+1]
return liste
else:
return file

def est_vide(file):
"""Retourne vrai si la file est vide"""
return(file == [])

Ceci est UNE implémentation possible. A la fin, la manière avec laquelle la file est implémentée n’a pas d’importance
réelle tant que le fonctionnement global correspond à du first in last out.

8.3 Exercices

Exercice N°10
On donne la séquence d’instructions
suivante :
Illustrer le résultat de chaque étape de cette séquence :
f = creer_file_vide()
f = enfiler(f,4)
f = enfiler(f,1)
f = enfiler(f,3)
n = defiler(f)
f = enfiler(f,8)
n = defiler(f)

CHAPITRE 3–Structures de données 18

 N.S.I Term

Exercice N°11
On donne la file liste_attente = ["Cersei","Jaime"] , illustrer à l’aide de schéma toutes les étapes de liste et file lors de
l’instruction enfiler(liste_attente, "Tyrion")

Exercice N°12
On suppose que l’on a déjà un saisis dans l’ordre alphabétique tab_1 = ["A", "B", "C", "D", "E"] tableau tab_1 qui
contient les éléments suivants

1. Quel est l’élément issu d’un défilage de tab_1 ?

……………………………………………………………………………………………………………………………………………………………………………………

2. Proposer une séquence d’instructions (à l’aide de deux piles P1 et P2) qui crée une pile
["E", "D", "C", "B", "A"] puis inverse l’ordre chronologique. (en 10 lignes). Accompagné d’un schéma c’est
mieux !

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

CHAPITRE 3–Structures de données 19

 N.S.I Term
……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

Exercice N°13
La notation polonaise inversée (NPI) permet d’écrire des opérations arithmétiques, sans utiliser de parenthèses. Ici,
nous nous limiterons à des nombres entiers naturels et aux opérations +, -, * et / sur eux. Dans cette notation, les
opérateurs sont écrits après les opérandes (nombre entiers naturels). Par exemple l’expression :

13∗( 3+2 ) donne en NPI  3 2+13∗¿

On écrit et on exécute les opérations dans le sens des priorités vues en cours de mathématiques. Dans cette
notation, on réalise :
 L’addition entre 3 et 2 (3 2 +)
 La multiplication entre le précédent résultat et 13 (13 *)
 On a ainsi le résultat.

1. Donner la file correspondante à la saisie NPI de l’exemple. Faire de même avec la pile.
2. Quelle est la structure adaptée à la résolution de l’expression ?On notera qu’il faut stocker le résultat
intermédiaire dans la structure pour effectuer la saisie des calculs.
3. En utilisant les opérations du type Pile, proposer une permettant d’afficher le résultat d’une expression en
NPI. On va considérer qu’on a déjà la fonction inverser_pile(pile) qui retourne une pile qui est dans l’ordre
inverser de celle donnée en argument

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………
CHAPITRE 3–Structures de données 20
 N.S.I Term
……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

CHAPITRE 3–Structures de données 21

 N.S.I Term
……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

CHAPITRE 3–Structures de données 22

 N.S.I Term
……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………

……………………………………………………………

CHAPITRE 3–Structures de données 23