Numérique et sciences informatiques (spécialité) · TerminaleBac

Piles et files : cours de Terminale NSI

Publié le 7 novembre 2026 · Mis à jour le 7 novembre 2026 · Signaler une erreur

L'essentiel

Une pile fonctionne en LIFO : le dernier élément ajouté est le premier retiré ².
Une file fonctionne en FIFO : le premier arrivé est le premier servi ².
Les primitives d'une pile sont est_vide, empiler (push) et depiler (pop) ².
On peut implanter une file avec deux piles ¹ : une pile d'entrée et une pile de sortie, avec un transfert quand la sortie est vide.
Piles et files sont des structures abstraites : on les utilise par leurs primitives, sans dépendre de leur implantation.

Pourquoi des structures à accès restreint ?

Jusqu'ici, tu as manipulé des listes dans lesquelles tu peux lire ou modifier n'importe quel élément. Les piles et les files font le choix inverse : elles limitent volontairement les opérations permises. Cette contrainte n'est pas un handicap. Elle garantit un ordre de traitement précis, facile à raisonner et à vérifier.

Les piles (stack en anglais) et les files (queue en anglais) sont des suites finies d'éléments dont l'accès est restreint : on ne peut pas atteindre n'importe quel élément à tout moment ². Ces structures, comme les listes, sont définies par un ensemble d'opérations plutôt que par la façon dont elles sont codées ¹.

Ce cours suit un parcours simple :

le principe de chaque structure (LIFO et FIFO) ;
les primitives, c'est-à-dire les opérations autorisées ;
une implantation en Python, avec la programmation orientée objet ;
l'implantation d'une file avec deux piles ;
les usages et les erreurs fréquentes.

Tu as besoin de deux notions vues avant : la programmation orientée objet (classes, attributs, méthodes) et les listes chaînées.

La pile : principe LIFO

Pour te représenter une pile, imagine des assiettes empilées sur une étagère : celle que tu saisis en premier est celle qui vient d'être posée en dernier ². Pour atteindre une assiette du fond, il faut d'abord retirer toutes celles qui sont au-dessus.

On parle de sommet pour désigner l'extrémité où se font tous les ajouts et tous les retraits. L'autre extrémité, le fond, n'est jamais accessible directement.

Pile et file côte à côte
Critère	Pile	File
Modèle	LIFO (dernier entré, premier sorti)	FIFO (premier entré, premier sorti)
Image	Assiettes empilées	Clients au guichet
Premier sorti	Le dernier arrivé	Le premier arrivé
Ajout	Au sommet (push)	À la queue
Retrait	Au sommet (pop)	À la tête

Pile et file côte à côte · Les modèles viennent du document de référence.

ExempleUne pile à la main

On part d'une pile vide. Le sommet est noté à droite.

Opération	État de la pile
empiler 3	[3]
empiler 8	[3, 8]
empiler 5	[3, 8, 5]
dépiler (rend 5)	[3, 8]
empiler 1	[3, 8, 1]
dépiler (rend 1)	[3, 8]

Si l'on vide ensuite toute la pile, les éléments sortent dans l'ordre 8 puis 3. Au total, l'ordre de sortie est 5, 1, 8, 3 : à chaque retrait, c'est le dernier arrivé parmi ceux qui sont présents.

La file : principe FIFO

Pense à des personnes qui patientent devant un guichet : ceux qui sont arrivés les premiers sont aussi les premiers à être pris en charge ². Contrairement à la pile, les deux extrémités jouent un rôle différent :

les éléments arrivent par une extrémité (la queue de la file) ;
les éléments partent par l'autre extrémité (la tête de la file).

On ne double jamais quelqu'un : l'ordre d'arrivée est l'ordre de départ.

ExempleUne file à la main

On note la tête à gauche et la queue à droite.

Opération	État de la file
enfiler A	[A]
enfiler B	[A, B]
enfiler C	[A, B, C]
défiler (rend A)	[B, C]
enfiler D	[B, C, D]
défiler (rend B)	[C, D]

L'ordre de sortie est A, B, puis C, puis D : exactement l'ordre d'arrivée.

Les primitives

Une structure de données se manipule par des primitives, c'est-à-dire un petit nombre d'opérations de base. Pour une pile, on implémente communément les suivantes ² :

est_vide (is empty) : teste si la pile est vide ² ;
push, ou empiler : ajoute un élément à la pile ² ;
pop, ou dépiler : retire un élément de la pile ².

Implanter une pile en Python

Le programme invite à utiliser la programmation orientée objet pour implanter ces structures ¹. Voici une pile fondée sur une liste Python dont la fin joue le rôle de sommet.

ExempleClasse Pile

class Pile:
    def __init__(self):
        self.elements = []

    def est_vide(self):
        return len(self.elements) == 0

    def empiler(self, x):
        self.elements.append(x)

    def depiler(self):
        if self.est_vide():
            raise IndexError("pile vide")
        return self.elements.pop()

    def sommet(self):
        if self.est_vide():
            raise IndexError("pile vide")
        return self.elements[-1]

Utilisation :

p = Pile()
p.empiler(3)
p.empiler(8)
print(p.depiler())   # affiche 8
print(p.est_vide())  # affiche False

Le dernier empilé (8) sort le premier : on retrouve le LIFO.

Implanter une file avec deux piles

Le programme suggère qu'on peut implanter une file en utilisant deux piles ¹, et le document d'accompagnement en détaille une version avec la programmation orientée objet ¹. L'idée est élégante : une pile inverse l'ordre des éléments, et inverser deux fois remet dans l'ordre d'origine.

EnfilerOn empile le nouvel élément sur la pile d'entrée.
Défiler : testerOn regarde si la pile de sortie est vide.
TransférerSi oui, on vide l'entrée dans la sortie : l'ordre s'inverse.
Dépiler la sortieLe sommet de la sortie est le plus ancien élément.

Une file avec deux piles · Le transfert n'a lieu que si la sortie est vide.

ExempleLe code

class File:
    def __init__(self):
        self.entree = Pile()
        self.sortie = Pile()

    def est_vide(self):
        return self.entree.est_vide() and self.sortie.est_vide()

    def enfiler(self, x):
        self.entree.empiler(x)

    def defiler(self):
        if self.sortie.est_vide():
            while not self.entree.est_vide():
                self.sortie.empiler(self.entree.depiler())
        return self.sortie.depiler()

Si la file est vide, self.sortie.depiler() lève l'exception de la classe Pile, ce qui signale correctement l'erreur.

À quoi servent piles et files ?

Ces structures reviennent dans de nombreux algorithmes dont tu verras la suite dans la partie sur les arbres et les graphes. Le document d'accompagnement consacre notamment un chapitre à l'usage des files dans les parcours de graphes et d'arbres ¹.

Les situations typiques se reconnaissent à l'ordre de traitement voulu :

Pile : annuler la dernière action (historique d'un éditeur), vérifier des parenthèses imbriquées, mémoriser où revenir après un appel de fonction.
File : traiter des demandes dans l'ordre d'arrivée (impressions, tâches), parcourir un graphe ou un arbre niveau par niveau ¹.

Piles et files

Pile
- LIFO
- Assiettes
- Sommet
File
- FIFO
- Attente
- Tête et queue
Primitives
- est_vide
- push
- pop
Implantation
- Liste Python
- Objet
- Deux piles
Usages
- Parenthèses
- Tâches
- Parcours

Piles et files : vue d'ensemble · Les grandes idées du chapitre.

Erreurs fréquentes et réflexes de contrôle

Exercices corrigés

Exercice 1 Suivre une pile

★☆☆Environ 5 min

On part d'une pile vide. On exécute dans l'ordre : empiler 4, empiler 7, dépiler, empiler 2, empiler 9, dépiler, dépiler.

Donne le contenu de la pile après chaque opération (sommet à droite).
Combien d'éléments restent-ils à la fin ?

Indice 1

Écris l'état de la pile après chaque ligne, sans en sauter.

Indice 2

Le nombre d'éléments restants est le nombre d'empilements moins le nombre de dépilements.

Voir la correction pas à pas

Après empiler 4 : [4].
Après empiler 7 : [4, 7].
Après dépiler : on retire 7, la pile est [4].
Après empiler 2 : [4, 2].
Après empiler 9 : [4, 2, 9].
Après dépiler : on retire 9, la pile est [4, 2].
Après dépiler : on retire 2, la pile est [4].
Il y a 4 empilements et 3 dépilements, donc 4 - 3 = 1 élément reste.

Il reste 1 élément, le 4, qui est au fond et au sommet à la fois. Les éléments retirés sont sortis dans l'ordre 7, 9, 2 : toujours le dernier arrivé parmi ceux présents.

Exercice 2 Suivre une file

★★☆Environ 8 min

On part d'une file vide (tête à gauche). On exécute : enfiler 'A', enfiler 'B', enfiler 'C', défiler, enfiler 'D', défiler, enfiler 'E'.

Donne le contenu de la file à la fin.
Quels éléments ont été renvoyés par les deux défilements ?
Quel est le prochain élément renvoyé par un défilement ?

Indice 1

Le défilement retire toujours l'élément le plus ancien présent.

Indice 2

Note la tête à gauche et la queue à droite, et ajoute à droite.

Voir la correction pas à pas

Après les trois enfilements : [A, B, C].
Premier défilement : on retire A, la file est [B, C].
Enfiler D : [B, C, D].
Second défilement : on retire B, la file est [C, D].
Enfiler E : [C, D, E].
Les défilements ont renvoyé A puis B, et le prochain renvoyé sera C.

La file finale est [C, D, E]. Les éléments sortent dans leur ordre d'arrivée, même quand des ajouts s'intercalent avec les retraits.

Exercice 3 Compter les opérations d'une file à deux piles

★★★Environ 12 min

Une file est implantée avec deux piles entree et sortie, comme dans le cours. On compte chaque empiler et chaque depiler sur une pile comme une opération élémentaire. On enfile 5 éléments dans une file vide, puis on défile une seule fois.

Combien d'opérations élémentaires coûtent les 5 enfilements ?
Combien coûte le défilement ?
Quel est le total ?

Indice 1

Un enfilement coûte un empilement sur entree.

Indice 2

Le transfert déplace chaque élément : un dépilement puis un empilement par élément.

Voir la correction pas à pas

Chaque enfilement est un empilement sur entree : 5 opérations pour les 5 éléments.
Au défilement, sortie est vide, donc on transfère les 5 éléments : 5 dépilements de entree et 5 empilements dans sortie, soit 10 opérations.
On dépile ensuite sortie pour renvoyer l'élément de tête : 1 opération, soit 11 pour le défilement.
Total : 5 + 11 = 16 opérations.

Le total est de 16 opérations. Le premier défilement est coûteux (11 opérations), mais les suivants, tant que sortie n'est pas vide, ne coûtent qu'un dépilement chacun.

Les questions qu'on se pose

Quelle différence retenir entre une pile et une file ?

Tout tient à l'élément qui sort en premier. Dans une pile (LIFO), c'est le dernier arrivé ². Dans une file (FIFO), c'est le premier arrivé ². Pour t'en souvenir, pense aux assiettes empilées et aux clients qui attendent.

Pourquoi implanter une file avec deux piles alors qu'une liste suffirait ?

Parce que c'est un excellent exercice pour comprendre la différence entre type abstrait et implantation, et parce que le programme le suggère ¹. Ça montre qu'une structure peut se construire à partir d'une autre sans changer son comportement vu de l'extérieur.

Que se passe-t-il si je dépile une pile vide ?

C'est une erreur : il n'y a rien à retirer. En Python, pop() sur une liste vide lève une exception IndexError. Teste est_vide avant ou gère l'exception. Ce cas est très souvent évalué dans les exercices du bac.

Comment reconnaître dans un énoncé qu'il faut une pile ou une file ?

Cherche l'ordre de traitement voulu. Si le dernier élément ajouté doit être traité en premier (annuler, imbriquer, revenir en arrière), c'est une pile. Si les éléments sont traités dans l'ordre d'arrivée (tâches, parcours niveau par niveau), c'est une file ¹.

Dois-je connaître les noms anglais des primitives ?

Oui, retiens push et pop pour la pile, ainsi que is empty ². Les énoncés peuvent utiliser les noms français ou anglais, parfois les deux, ce qui rend la correspondance utile.

Sources

Document accompagnement - Structures de données (Listes, Piles, Files), Éduscol / Ministère de l'Éducation nationale. Consulté le 7 novembre 2026.
Structures de données - Terminale NSI, CNRS - Enseignements de mathématiques. Consulté le 7 novembre 2026.
Pile Zoé, Wikipédia. Consulté le 7 novembre 2026.

Les numéros dans le texte renvoient à ces sources. Une source qui ne dit pas ce qu'on lui fait dire ? Signale-le.

Signaler une erreur sur cette page

Piles et files : cours de Terminale NSI

L'essentiel

Pourquoi des structures à accès restreint ?

La pile : principe LIFO

La file : principe FIFO

Les primitives

Implanter une pile en Python

Implanter une file avec deux piles

À quoi servent piles et files ?

Erreurs fréquentes et réflexes de contrôle

Exercices corrigés

Exercice 1 Suivre une pile

Exercice 2 Suivre une file

Exercice 3 Compter les opérations d'une file à deux piles

Quiz

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur