pour la suite on utilisera une nouvelle version de ce qui a été fait sur les liste chainée. Celle ci est décomposée en deux classes : Maillons() et ListeC().
On pourra ranger tout ça dans un fichier nommé listes_chainees.py
class Maillon():
def __init__(self, data = None):
self.data = data
self.suiv = None # adresse (en Python, on pointe directement vers un Maillon)
def __repr__(self):
t = str(self.data)
if self.suiv is not None:
return t + "→"
return t + "x"
class ListeC():
def __init__(self):
self.tete = None # adresse (en Python, on pointe directement vers un Maillon)
def __repr__(self):
m = self.tete
l = []
while m is not None:
l.append(str(m))
m = m.suiv
return "\n".join(l)
def est_vide(self):
""" Renvoie True si la liste est vide"""
return self.tete is None
def taille(self):
""" Renvoie le nombre de maillons de la liste"""
m = self.tete
l = 0
while m is not None:
l += 1
m = m.suiv
return l
def get_dernier(self):
"""Renvoie le der Maillon de la liste IndexError si liste est vide"""
if self.est_vide():
raise IndexError("listeC index out of range")
m = self.tete
while m.suiv is not None:
m = m.suiv
return m
def ajouter_fin(self, v):
""" Ajoute un élément à la fin de la liste chaînée"""
nM = Maillon(v)
if self.est_vide():
self.tete = nM
else:
dm = self.get_dernier()
dm.suiv = nM
def ajouter_debut(self, v):
""" Ajoute un élément au début de la liste chaînée"""
nM = Maillon(v)
if self.est_vide():
self.tete = nM
else:
nM.suiv = self.tete
self.tete = nM
def supprimer_debut(self):
""" Supprime et renvoie le premier élément de la liste chaînée
IndexError si la liste est vide"""
if self.tete is not None:
m = self.tete
self.tete = self.tete.suiv
return m.data
else:
raise IndexError("listeC index out of range")
def supprimer_fin(self):
""" Supprime et renvoie le dernier élément de la liste chaînée
IndexError si la liste est vide"""
if self.est_vide():
raise IndexError("listeC index out of range")
m = self.tete
if m.suiv is None: # 1 seul élément
self.tete = None
return m.data
a = None # avant dernier
while m.suiv is not None:
a = m
m = m.suiv
a.suiv = None
return m.data
M1,M2,M3=Maillon(4),Maillon(5),Maillon(7)
M4,M5,M6=Maillon(8),Maillon(-6),Maillon(-13)
M4.suiv=M5
M5.suiv=M6
liste1=ListeC()
liste1.ajouter_fin(M1)
liste1.ajouter_fin(M2)
liste1.ajouter_fin(M3)
print(repr(liste1))
print(repr(M1))
print(repr(M4))
print(repr(M6))
Définir en Python une classe Pile en utilisant une liste chaînée (objet de type ListeC du module listes_chainees ) comme conteneur de données.
À l’aide de seulement 3 méthodes de la classe ListeC , réaliser l’interface complète de cette pile (méthodes est_vide, empiler, et depiler).
À l’aide uniquement des 3 méthodes de l’interface de Pile , réaliser une méthode de représentation (repr).
On pourra utiliser les caractères unicode de « boite » suivants : « ─ » , « └ » , « ┘ » et « │ » Avec un Tableau
Définir en Python une classe Pile en utilisant une liste Python comme conteneur de données.
À l’aide de seulement 2 méthodes et une fonction, réaliser l’interface complète de cette pile.
class Pile:
def __init__(self):
def __repr__(self):
def est_vide(self):
def depiler(self):
def empiler(self, n):
correction
from listes_chainees import *
class Pile:
def __init__(self):
self.__l = [] # attribut privé : on ne doit utiliser que l'interface élémentaire
# Pour internationaliser les méthodes :
self.pop = self.depiler
self.push = self.empiler
self.is_empty = self.est_vide
def __repr__(self):
l = []
p = Pile()
m = 0
while not self.est_vide():
c = self.depiler()
l.append(str(c))
p.empiler(c)
m = max(m, len(str(c)))
# on reconstruit la Pile d'origine
while not p.est_vide():
self.empiler(p.depiler())
# Pour afficher une bordure :
for i in range(len(l)):
l[i] = "│" + l[i].ljust(m) +"│"
return "\n".join(l) + "\n└"+ m*"─" + "┘"
def est_vide(self):
return len(self.__l) == 0
def depiler(self):
return self.__l.pop()
def empiler(self, n):
self.__l.append(n)