From a17b7367ec9e728722c5f8a318fef4a5545f7134 Mon Sep 17 00:00:00 2001
From: arthur <barraux.a@example.com>
Date: Wed, 25 Jan 2023 11:56:52 +0100
Subject: [PATCH] first commit

---
 data_structure.py | 327 ++++++++++++++++++++++++++++++++++++++++++++++
 main.py           |  11 ++
 2 files changed, 338 insertions(+)
 create mode 100644 data_structure.py
 create mode 100644 main.py

diff --git a/data_structure.py b/data_structure.py
new file mode 100644
index 0000000..a4c6ec2
--- /dev/null
+++ b/data_structure.py
@@ -0,0 +1,327 @@
+#!/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
+
+
+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) + "->|"
+
+
+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"
+
+
+class Arbre:
+    def __init__(self, val) -> None:
+        self.val = val
+        self.gauche = None
+        self.droit = None
+
+    def insere_gauche(self, val) -> object:
+        """insere un arbre gauche a la racine de l'arbre"""
+        nouvel_arbre = Arbre(val)
+        nouvel_arbre.gauche = self.gauche
+        self.gauche = nouvel_arbre
+        return nouvel_arbre
+
+    def insere_droit(self, val) -> object:
+        """insere un arbre gauche a la racine de l'arbre"""
+        nouvel_arbre = Arbre(val)
+        nouvel_arbre.gauche = self.droit
+        self.droit = nouvel_arbre
+        return nouvel_arbre
+
+
+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())
+    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)
+    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())
\ No newline at end of file
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..8769fc3
--- /dev/null
+++ b/main.py
@@ -0,0 +1,11 @@
+from data_structure import *
+
+class Expression:
+    """manipule les expression sous forme d'arbre"""
+    def __init__(self, val, fils_gauche, fils_droit) -> None:
+        self.Val = val
+        self.fils_gauche = fils_gauche
+        self.fils_droit = fils_droit
+
+    def evalue(self, val: float):
+        pass
\ No newline at end of file