Les piles
Vérifier que les parenthèses de {[()()]} s'associent correctement demande une pile et 8 empilements et dépilements, un par parenthèse.
Dernier entré, premier sorti
Pense à une pile d'assiettes. Tu poses une assiette propre sur le dessus, et quand tu en as besoin, tu la prends sur le dessus. L'assiette ajoutée en dernier est la première à sortir. Une pile est une structure de données qui suit exactement cette règle, appelée dernier entré, premier sorti (LIFO en anglais). Elle offre deux opérations principales : empiler (push) pose une valeur au sommet, et dépiler (pop) retire la valeur du sommet et la renvoie. Beaucoup de piles proposent aussi consulter (peek), qui regarde le sommet sans le retirer.
Dans les notes du cours 6.006 du MIT, la pile est un cas particulier de l'interface de séquence : insert last(x) et delete last(). Cela indique déjà comment en construire une. On range les valeurs dans un tableau dynamique et on traite la fin du tableau comme le sommet. Dans l'unité précédente, la fin était le côté bon marché : empiler et dépiler coûtent donc chacun 1 étape (amortie, à cause de la copie occasionnelle). La taille de la pile ne change rien. Dépiler une pile de 3 valeurs ou de 3 millions de valeurs, c'est la même étape unique.
const stack = [];
stack.push(4);
stack.push(8);
stack.push(5);
console.log(stack.pop()); // 5, le dernier empilé
console.log(stack[stack.length - 1]); // consulter : 8
console.log(stack.length); // affiche 2Fais glisser pour tourner. Fais défiler ou pince pour zoomer.
Vérifier des parenthèses
Un usage classique de la pile consiste à vérifier que les parenthèses sont équilibrées, ce que font tous les éditeurs de code et tous les compilateurs. On lit le texte de gauche à droite. Chaque parenthèse ouvrante, (, [ ou {, est empilée. Chaque parenthèse fermante doit correspondre à l'ouvrante au sommet de la pile : si c'est le cas, on dépile cette ouvrante ; si la pile est vide ou que le sommet est d'une autre sorte, la suite n'est pas équilibrée. À la fin, la pile doit être vide, sinon une ouvrante n'a jamais été fermée.
Essaie les suites du labo. {[()()]} demande 4 empilements et 4 dépilements, 8 étapes, et se termine avec une pile vide. ([)] échoue au troisième caractère : le ) arrive alors que [ est au sommet. (() est lu jusqu'au bout avec un ( en trop. Pourquoi une pile convient-elle à ce travail ? Les parenthèses s'imbriquent, et la dernière ouverte doit être la première fermée. C'est le principe dernier entré, premier sorti.
Où l'on retrouve aussi des piles
- La pile d'appels. Quand la fonction a appelle b et que b appelle c, l'ordinateur empile un enregistrement pour chaque appel. Quand c se termine, son enregistrement est dépilé et b reprend là où il s'était arrêté. Une récursion infinie remplit cette pile : c'est l'erreur de « débordement de pile » (stack overflow).
- Annuler. Un éditeur empile chaque modification. Annuler dépile la modification la plus récente et la défait.
- Le bouton Retour. Un navigateur empile chaque page que tu quittes ; Retour dépile la dernière.
- Le parcours en profondeur. Le cours d'algorithmique utilisait une pile pour aller aussi loin que possible dans un labyrinthe avant de revenir en arrière.
- Dans quel ordre une pile rend-elle les valeurs ?
- Premier entré, premier sorti
- Dernier entré, premier sorti
- La plus petite d'abord
- Dans un ordre aléatoire
- On part d'une pile vide. On empile 4, on empile 8, on empile 5, on dépile, on empile 2. Qu'y a-t-il au sommet ?
- 4
- 8
- 5
- 2
- Après ces opérations, combien de valeurs y a-t-il sur la pile ?
- Empile A, puis B, puis C, puis dépile jusqu'à ce que la pile soit vide. Range les valeurs dépilées dans l'ordre.
- Combien d'empilements et de dépilements au total demande la vérification de {[()()]} avec la méthode des parenthèses ?
- En vérifiant ([)] depuis la gauche, où l'échec se produit-il ?
- Au premier (
- Au [
- Au )
- Au ] final
- Qu'est-ce qui ne va pas dans (() ?
- Une fermante arrive sur une pile vide
- Un ( est encore sur la pile à la fin
- Il manque des crochets
- Rien ; c'est équilibré
- Dépiler une pile (stockée dans un tableau dynamique) qui contient 1000 valeurs prend combien d'étapes ?
- La fonction main appelle draw, et draw appelle line. Pendant que line s'exécute, quel enregistrement est au sommet de la pile d'appels ?
- main
- draw
- line
- aucun
- En quelle année Bauer et Samelson ont-ils déposé leur demande de brevet pour la méthode de la pile ?
- 1946
- 1957
- 1962
- 1972
- Une pile suit la règle dernier entré, premier sorti : on empile au sommet, on dépile au sommet.
- Construites sur la fin d'un tableau dynamique, les opérations push et pop coûtent 1 étape chacune.
- La vérification des parenthèses empile les ouvrantes et dépile à chaque fermante ; {[()()]} prend 8 étapes.
- La pile d'appels, l'annulation et le bouton Retour sont des piles.
Sources de ce cours (11)
- MIT OpenCourseWare 6.006 Introduction to Algorithms, Spring 2020 (Demaine, Ku, Solomon)
- lecture notes 2 Data Structures (interface vs data structure, Sequence and Set interfaces, stack = insert_last/delete_last, queue = insert_last/delete_first, array, linked list, dynamic array, amortized Θ(1) append)
- 4 Hashing (chaining, pigeonhole collisions, chain length n/m)
- 6 Binary Trees Part 1 (height, traversal order, O(h) operations) and 7 Binary Trees Part 2: AVL (Adelson-Velsky and Landis, 1962) at ocw.mit.edu/courses/6-006-introduction-to-algorithms-spring-2020/pages/lecture-notes
- MDN Web Docs, Array.prototype.shift (shifts all values left by 1)
- Array.prototype.unshift, Map (insertion order, Map vs Object, spec requires sublinear average access) and Set (developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects)
- ECMAScript 2025 Language Specification (tc39.es/ecma262)
- 24.1 Map Objects and 24.2 Set Objects ("must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements")
- Array.prototype.shift steps (Repeat, while k < len: move element k to k - 1)
- D. E. Knuth, The Art of Computer Programming vol. 3 (2nd ed. 1998) section 6.4 History (H. P. Luhn, IBM internal memorandum January 1953, hashing with chaining; digit pairs added mod 10, 31415926 -> 4548) via gwern.net copy, and IEEE Spectrum, "Hans Peter Luhn and the Birth of the Hashing Algorithm" (2018)
- "A brief history of the stack", SIGCIS (sigcis.org/files/A brief history.pdf: Bauer and Samelson applied for the patent in 1957, US 3,047,228 granted July 31, 1962; IPL list processing by Newell, Simon and Shaw at RAND 1956) and Wikipedia, Information Processing Language (Newell, Shaw, Simon, RAND and Carnegie Institute of Technology, about 1956).
Consulté le: 2026-10-18