From dc2750771f938a0869ab26b84d2eea82674cc5aa Mon Sep 17 00:00:00 2001
From: erika <>
Date: Mon, 27 Jan 2025 11:46:05 +0100
Subject: [PATCH] suite

---
 File.py        | 114 +++++++++++++++++++++++++++++++++++++++++++++++++
 Pile.py        |  91 +++++++++++++++++++++++++++++++++++++++
 calculette.py  | 103 ++++++++++++++++----------------------------
 listeChaine.py | 111 +++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 353 insertions(+), 66 deletions(-)
 create mode 100644 File.py
 create mode 100644 Pile.py
 create mode 100644 listeChaine.py

diff --git a/File.py b/File.py
new file mode 100644
index 0000000..05b51dc
--- /dev/null
+++ b/File.py
@@ -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())
diff --git a/Pile.py b/Pile.py
new file mode 100644
index 0000000..3f198b5
--- /dev/null
+++ b/Pile.py
@@ -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())
diff --git a/calculette.py b/calculette.py
index 30edf2d..dc5c0c3 100644
--- a/calculette.py
+++ b/calculette.py
@@ -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
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-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 
-            
-
-
+    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 *  :
+        
+        
+     #   else :
+        
+   # return
+        
+        
\ No newline at end of file
diff --git a/listeChaine.py b/listeChaine.py
new file mode 100644
index 0000000..5c491ef
--- /dev/null
+++ b/listeChaine.py
@@ -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)