erika
4 weeks ago
4 changed files with 353 additions and 66 deletions
@ -0,0 +1,114 @@ |
|||
#!/usr/bin/env python3 |
|||
# -*- coding: utf-8 -*- |
|||
|
|||
class File_lst: |
|||
"""Implémentation d'une file par une liste.""" |
|||
def __init__(self): |
|||
"""Crée une file vide.""" |
|||
self.__file = [] |
|||
|
|||
def est_vide(self): |
|||
"""Indique si la file est vide.""" |
|||
return self.__file == [] |
|||
|
|||
def enfiler(self, valeur): |
|||
"""Enfile l'élément valeur.""" |
|||
self.__file.append(valeur) |
|||
|
|||
def defiler(self): |
|||
"""Défile la tête de la file et la renvoie.""" |
|||
return self.__file.pop(0) |
|||
|
|||
def taille(self): |
|||
"""Renvoie la taille de la file.""" |
|||
return len(self.__file) |
|||
|
|||
def tete(self): |
|||
"""Renvoie la tête de la file (sans la défiler).""" |
|||
return self.__file[0] |
|||
|
|||
def __str__(self): |
|||
s = "tete<-" |
|||
for val in self.__file: |
|||
s += str(val) + "<-" |
|||
return s + "queue" |
|||
|
|||
|
|||
class Maillon: |
|||
"""Un maillon d'une liste doublement chaînée.""" |
|||
def __init__(self, precedent, valeur, suivant): |
|||
self.valeur = valeur |
|||
self.precedent = precedent |
|||
self.suivant = suivant |
|||
|
|||
def __str__(self): |
|||
return str(self.valeur) |
|||
|
|||
|
|||
class File_chaine: |
|||
"""Implémentation d'une file par une liste doublement chaînée.""" |
|||
def __init__(self): |
|||
"""Crée une file vide.""" |
|||
self.__debut = self.__fin = None |
|||
self.__taille = 0 |
|||
|
|||
def est_vide(self): |
|||
"""Indique si la file est vide.""" |
|||
return self.__taille == 0 |
|||
|
|||
def enfiler(self, valeur): |
|||
"""Enfile l'élément valeur.""" |
|||
maillon = Maillon(self.__fin, valeur, None) |
|||
if self.est_vide(): |
|||
self.__debut = self.__fin = maillon |
|||
else: |
|||
self.__fin.suivant = maillon |
|||
self.__fin = maillon |
|||
self.__taille += 1 |
|||
|
|||
def defiler(self): |
|||
"""Défile la tête de la file et la renvoie.""" |
|||
if self.est_vide(): |
|||
raise IndexError("Impossible de défiler une file vide.") |
|||
valeur = self.__debut.valeur |
|||
self.__taille -= 1 |
|||
if self.est_vide(): |
|||
self.__debut = self.__fin = None |
|||
else: |
|||
self.__debut = self.__debut.suivant |
|||
self.__debut.precedent = None |
|||
return valeur |
|||
|
|||
def taille(self): |
|||
"""Renvoie la taille de la file.""" |
|||
return self.__taille |
|||
|
|||
def tete(self): |
|||
"""Renvoie la tête de la file (sans la défiler).""" |
|||
if self.est_vide(): |
|||
raise IndexError("Une file vide n'a pas de tête.") |
|||
return self.__debut.valeur |
|||
|
|||
def __str__(self): |
|||
s = "tete<-" |
|||
maillon = self.__debut |
|||
while maillon is not None: |
|||
s += str(maillon) + "<-" |
|||
maillon = maillon.suivant |
|||
return s + "queue" |
|||
|
|||
|
|||
if __name__ == "__main__": |
|||
f = File_lst() |
|||
print(f.est_vide()) |
|||
f.enfiler('A') |
|||
f.enfiler('B') |
|||
f.enfiler('C') |
|||
print(f.est_vide()) |
|||
print(f.tete()) |
|||
print(f) |
|||
print(f.taille()) |
|||
print(f.defiler()) |
|||
print(f.defiler()) |
|||
print(f.defiler()) |
|||
print(f.est_vide()) |
|||
@ -0,0 +1,91 @@ |
|||
#!/usr/bin/env python3 |
|||
# -*- coding: utf-8 -*- |
|||
|
|||
from listeChaine import ListeChaine |
|||
|
|||
class Pile_lst: |
|||
"""Implémentation d'une pile par une liste.""" |
|||
def __init__(self): |
|||
"""Crée une pile vide.""" |
|||
self.__pile = [] |
|||
|
|||
def est_vide(self): |
|||
"""Indique si la pile est vide.""" |
|||
return self.__pile == [] |
|||
|
|||
def empiler(self, valeur): |
|||
"""Empile la valeur.""" |
|||
self.__pile.append(valeur) |
|||
|
|||
def depiler(self): |
|||
"""Dépile le sommet de la pile et le renvoie.""" |
|||
return self.__pile.pop() |
|||
|
|||
def taille(self): |
|||
"""Renvoie la taille de la pile.""" |
|||
return len(self.__pile) |
|||
|
|||
def sommet(self): |
|||
"""Renvoie le sommet de la pile (sans le dépiler).""" |
|||
return self.__pile[-1] |
|||
|
|||
def __str__(self): |
|||
s = "|" |
|||
for val in self.__pile: |
|||
s = str(val) + "->" + s |
|||
return s |
|||
|
|||
|
|||
class Pile_chaine: |
|||
"""Implémentation d'une pile par une liste chaînée.""" |
|||
def __init__(self): |
|||
"""Crée une pile vide.""" |
|||
self.__pile = ListeChaine() |
|||
self.__taille = 0 |
|||
|
|||
def est_vide(self): |
|||
"""Indique si la pile est vide.""" |
|||
return self.__taille == 0 |
|||
|
|||
def empiler(self, valeur): |
|||
"""Empile la valeur.""" |
|||
self.__pile.ajoute(valeur) |
|||
self.__taille += 1 |
|||
|
|||
def depiler(self): |
|||
"""Dépile le sommet de la pile et le renvoie.""" |
|||
if self.est_vide(): |
|||
raise IndexError("Impossible de dépiler une pile vide.") |
|||
valeur = self.__pile.tete() |
|||
self.__pile = self.__pile.queue() |
|||
self.__taille -= 1 |
|||
return valeur |
|||
|
|||
def taille(self): |
|||
"""Renvoie la taille de la pile.""" |
|||
return self.__taille |
|||
|
|||
def sommet(self): |
|||
"""Renvoie le sommet de la pile (sans le dépiler).""" |
|||
if self.est_vide(): |
|||
raise IndexError("Une pile vide n'a pas de sommet.") |
|||
return self.__pile.tete() |
|||
|
|||
def __str__(self): |
|||
return str(self.__pile) + "->|" |
|||
|
|||
|
|||
if __name__ == "__main__": |
|||
p = Pile_lst() |
|||
print(p.est_vide()) |
|||
p.empiler('A') |
|||
p.empiler('B') |
|||
p.empiler('C') |
|||
print(p.est_vide()) |
|||
print(p.sommet()) |
|||
print(p) |
|||
print(p.taille()) |
|||
print(p.depiler()) |
|||
print(p.depiler()) |
|||
print(p.depiler()) |
|||
print(p.est_vide()) |
|||
@ -1,71 +1,42 @@ |
|||
from File import File_chaine as File |
|||
from Pile import Pile_chaine as Pile |
|||
|
|||
def creer_arbre(val): |
|||
""" Renvoie un nouvel arbre dont la racine est val . """ |
|||
return [val, None, None] |
|||
|
|||
def est_vide(a): |
|||
""" Indique si l ' arbre a est vide ou non. """ |
|||
return a == None |
|||
|
|||
def racine(a): |
|||
""" Renvoie la racine de l ' arbre non vide a. """ |
|||
return a [0] |
|||
|
|||
def fils_gauche(a): |
|||
""" Renvoie le fils gauche de l ' arbre non vide a. """ |
|||
return a [1] |
|||
|
|||
def fils_droit(a): |
|||
""" Renvoie le fils droit de l ' arbre non vide a. """ |
|||
return a [1] |
|||
|
|||
def insere_gauche(a, val): |
|||
""" Insère la valeur val à la racine du fils gauche de l'arbre non vide a. |
|||
L'ancien fils gauche de a devient le fils gauche du nouveau nœud. |
|||
Renvoie le sous arbre créé . """ |
|||
nouvel_arbre = |
|||
nouvel_arbre[1] = |
|||
. . .. . = nouvel_arbre |
|||
return nouvel_arbre |
|||
|
|||
def insere_droit(a, val): |
|||
""" Ins è re la valeur val à la racine du fils droit de l ' arbre non vide a. |
|||
L ' ancien fils droit de a devient le fils gauche du nouveau nœud. |
|||
Renvoie le sous arbre cr éé . """ |
|||
nouvel_arbre = . . . .. . . . . .. . . . . . |
|||
nouvel_arbre[1] = . . .. . . . . . .. . . . |
|||
. . .. . = nouvel_arbre |
|||
return nouvel_arbre |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
class Expression: |
|||
def __init__(self, valeur, gauche=None, droite=None): |
|||
|
|||
self.valeur = valeur |
|||
self.gauche = gauche |
|||
self.droite = droite |
|||
|
|||
def evalue(self): |
|||
|
|||
if type(self.valeur) == int: |
|||
return self.valeur |
|||
|
|||
if self.valeur == '+': |
|||
return self.gauche.evalue() + self.droite.evalue() |
|||
if self.valeur == '*': |
|||
return self.gauche.evalue() * self.droite.evalue() |
|||
|
|||
def __str__(self): |
|||
if type(self.valeur) == int: |
|||
return str(self.valeur) |
|||
else : |
|||
return "({str(self.gauche)} {self.valeur} {str(self.droite)})" |
|||
|
|||
class Conversion: |
|||
lst = [self.valeur,self.gauche, self.droite] |
|||
def npi2tree (lst): |
|||
"""fonction npi2tree prenant en paramètre une liste correspondant à l’expression en notation |
|||
polonaise inversée et renvoyant l’arbre (de type Expression) correspondant""" |
|||
p = Pile(lst) |
|||
# for i in lst (): |
|||
# if + or * : |
|||
|
|||
|
|||
a = Arbre () |
|||
class Expression: |
|||
def __init__(self, racine, fils_gauche, fils_droit): |
|||
type (racine) = '+' or '*' or int |
|||
if type(racine) == int: |
|||
fils_gauche = none or a |
|||
# else : |
|||
|
|||
# return |
|||
|
|||
|
|||
@ -0,0 +1,111 @@ |
|||
#!/usr/bin/env python3 |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
Created on Tue Sep 22 20:44:35 2020 |
|||
|
|||
@author: manu |
|||
""" |
|||
|
|||
|
|||
class Maillon: |
|||
"""Un maillon d'une liste chaînée.""" |
|||
def __init__(self, valeur, suivant): |
|||
self.valeur = valeur |
|||
self.suivant = suivant |
|||
|
|||
def __str__(self): |
|||
"""Renvoie une chane de caractères représentant le maillon.""" |
|||
return str(self.valeur) |
|||
|
|||
|
|||
class ListeChaine: |
|||
"""Une liste chaînée.""" |
|||
def __init__(self, tete=None): |
|||
"""Crée une liste vide, ou une liste dont la tete (un maillon) |
|||
est donnée.""" |
|||
self.__tete = tete |
|||
|
|||
def est_vide(self): |
|||
"""Indique si la liste est vide.""" |
|||
return self.__tete is None |
|||
|
|||
def tete(self): |
|||
"""Renvoie la valeur du premier élément de la liste.""" |
|||
if self.est_vide(): |
|||
raise IndexError("La liste vide n'a pas de tête") |
|||
return self.__tete.valeur |
|||
|
|||
def queue(self): |
|||
"""Renvoie la queue de la liste.""" |
|||
if self.est_vide(): |
|||
raise IndexError("La liste vide n'a pas de queue") |
|||
return ListeChaine(self.__tete.suivant) |
|||
|
|||
def ajoute(self, valeur): |
|||
"""ajoute `valeur` en tête de la liste.""" |
|||
self.__tete = Maillon(valeur, self.__tete) |
|||
|
|||
def __str__(self): |
|||
"""Renvoie une chaîne de caractères représentant la liste.""" |
|||
maillon = self.__tete |
|||
s = '' |
|||
while maillon is not None: |
|||
s = s + str(maillon.valeur) |
|||
maillon = maillon.suivant |
|||
if maillon is not None: |
|||
s += '->' |
|||
return s |
|||
|
|||
def __len__(self): |
|||
"""Renvoie la longueur de la liste.""" |
|||
maillon = self.__tete |
|||
long = 0 |
|||
while maillon is not None: |
|||
long = long + 1 |
|||
maillon = maillon.suivant |
|||
return long |
|||
|
|||
def __getitem__(self, n): |
|||
"""Renvoie l'élément d'indice n de la liste.""" |
|||
maillon = self.__tete |
|||
i = 0 |
|||
while i < n and maillon is not None: |
|||
i = i + 1 |
|||
maillon = maillon.suivant |
|||
if maillon is None or n < 0: |
|||
raise IndexError("Indice non valide") |
|||
return maillon.valeur |
|||
|
|||
def __add__(self, other): |
|||
"""Renvoie la liste correspondant à la concaténation des 2 listes.""" |
|||
if self.est_vide(): |
|||
return other |
|||
v = self.tete() |
|||
q = self.queue() |
|||
return ListeChaine(Maillon(v, (q + other).__tete)) |
|||
|
|||
def reverse(self): |
|||
"""Renvoie une liste correspondant à la liste renversée.""" |
|||
res = ListeChaine() |
|||
maillon = self.__tete |
|||
while maillon is not None: |
|||
res.ajoute(maillon.valeur) |
|||
maillon = maillon.suivant |
|||
return res |
|||
|
|||
|
|||
if __name__ == "__main__": |
|||
lst = ListeChaine() |
|||
print(lst.est_vide()) |
|||
lst.ajoute(306) |
|||
lst.ajoute(42) |
|||
lst.ajoute(205) |
|||
print(lst) |
|||
print(lst.est_vide()) |
|||
print(lst[0]) |
|||
print(lst[1]) |
|||
print(len(lst)) |
|||
lst2 = ListeChaine() |
|||
lst2.ajoute(18) |
|||
lst2.ajoute(45) |
|||
print(lst + lst2) |
|||
Loading…
Reference in new issue