#!/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())