Module ldc.partie2
Toutes les méthodes permettant de travailler sur l'ordre des listes doublement chainées
Expand source code
#!/usr/bin/python3
#-*- coding: utf8 -*-
# @author : Sébastien LOZANO
"""
Toutes les méthodes permettant de travailler sur l'ordre des listes doublement chainées
"""
pass
# Pour mesurer le temps de traitement du script
from datetime import datetime
# Pour les commandes systeme
import os
from partie1 import *
#############################################################################################
# FONCTIONS
#############################################################################################
def estOrdonneeLDC(ldc:list)->bool:
"""Renvoie True si la liste doublement chainée **ldc** est croissante au sens large.
Doublons possibles.
**Paramètres**
* ldc -- liste doublement chainée.
**Sorties**
* Un booléen.
"""
pass
assert (ldc is not None),warnString("La liste est vide, on ne peut pas statuer sur l'ordre de ses élements.")
assert (estNoeudLDC(getPrecedentLDC(ldc)) and estNoeudLDC(getSuivantLDC(ldc))) # msg issu de estNoeudLDC
myBool = False
p = 0
noeud = ldc
while (p<longueurLDC(ldc)-1 and getValLDC(noeud)<=getValLDC(getSuivantLDC(noeud))):
noeud = getSuivantLDC(noeud)
p += 1
if (p == longueurLDC(ldc)-1):
myBool = True
return myBool
def triLDC(ldc:list)->list:
"""Renvoie la liste doublement chainée **ldc** triée dans l'ordre croissant au sens large.
Doublons possibles.
**Paramètres**
* ldc -- liste doublement chainée.
**Sorties**
* la liste doublement chainée triée dans l'ordre croissant.
"""
pass
assert (ldc is not None),warnString("La liste est vide, on ne peut pas trier ses élements.")
assert (estNoeudLDC(getPrecedentLDC(ldc)) and estNoeudLDC(getSuivantLDC(ldc))) # msg issu de estNoeudLDC
# On transforme la liste doublement chainee en liste Python
ldc2listPython = LDC2List(ldc)
# On trie la liste
ldc2listPython.sort()
# On retransforme en liste doublement chainée
ldc = list2LDC(ldc2listPython)
return ldc
def insereOrdreLDC(ldc:list,val:int)->list:
"""Insère la valeur **val** à sa place dans la liste doublement chainée **ldc** croissante, demanière à ce qu'elle reste croissante au sens large.
Doublons possibles.
**Paramètres**
* ldc -- liste doublement chainée.
**Sorties**
* la liste doublement chainée triée dans l'ordre croissant.
"""
pass
assert (ldc is None) or estOrdonneeLDC(ldc),warnString(str(LDC2List(ldc))+" devrait être ordonnée")
assert (ldc is None) or (estNoeudLDC(getPrecedentLDC(ldc)) and estNoeudLDC(getSuivantLDC(ldc))) # msg issu de estNoeudLDC
assert isinstance(val,int),warnString(str(val)+" devrait être un entier")
if ldc is None:
ldc = []
ldc = creerNoeudLDC(val,None,None)
else:
i = 0 # pourl'indice courant
currentNode = ldc
while getValLDC(currentNode)<val:
currentNode = getSuivantLDC(currentNode)
i += 1
# Quand on sort de la boucle on a l'indice d'insertion
insererPlaceLDC(ldc,val,i)
return ldc
#############################################################################################
# TESTS
#############################################################################################
def tests_estOrdnneeLDC():
"""Teste la fonction estOrdonneeLDC()"""
listeVide = creerListeVide()
# On crée une liste doublement chainée ordonnée
ldcOrdonnee = list2LDC([0,1,2])
# On crée une liste doublement chainée ordonnée avec doublons
ldcOrdonneeDoublons = list2LDC([0,1,1,2])
# On crée une liste doublement chainée non-ordonnée
ldcNonOrdonnee = list2LDC([0,2,1])
# On crée une liste doublement chainée non-ordonnée avec des doublons
ldcNonOrdonneeDoublons = list2LDC([0,2,1,3,2])
# Pour lever les erreurs d'assertions
# On crée des noeuds pour faire une liste de noeuds
noeud1 = creerNoeudLDC(1,None,None)
noeud2 = creerNoeudLDC(2,None,None)
setSuivantLDC(noeud1,noeud2)
setPrecedentLDC(noeud2,noeud1)
ldcKO = ['string',noeud1,noeud2]
myTestsTitle("estOrdonneeLDC()")
print("ldcOrdonnee : ",ldcOrdonnee)
print("estOrdonneeLDC(ldcOrdonnee) : ",estOrdonneeLDC(ldcOrdonnee))
print(sepSymb("-"))
print("ldcOrdonneedoublons : ",ldcOrdonneeDoublons)
print("estOrdonneeLDC(ldcOrdonneeDoublons) : ",estOrdonneeLDC(ldcOrdonneeDoublons))
print(sepSymb("-"))
print("ldcNonOrdonnee : ",ldcNonOrdonnee)
print("estOrdonneeLDC(ldcNonOrdonnee) : ",estOrdonneeLDC(ldcNonOrdonnee))
print(sepSymb("-"))
print("ldcNonOrdonneeDoublons : ",ldcNonOrdonneeDoublons)
print("estOrdonneeLDC(ldcNonOrdonneeDoublons : ",estOrdonneeLDC(ldcNonOrdonneeDoublons))
# Tests pour lever les erreurs d'assertion
myAssertTestsTitle("estOrdonneeLDC() -> test des assertions")
try:
print(warnString("listeVide ->"+str(listeVide)))
estOrdonneeLDC(listeVide)
except AssertionError as msg:
print(warnString("estOrdonneeLDC(listeVide) ->"),msg)
print(warnString(sepSymb("-")))
try:
print(warnString("ldcKO ->"+str(ldcKO)))
estOrdonneeLDC(ldcKO)
except AssertionError as msg:
print(warnString("estOrdonneeLDC(ldcKO) ->"),msg)
def tests_triLDC():
"""Teste la fonction triLDC()"""
listeVide = creerListeVide()
# On crée une liste doublement chainée ordonnée
ldcOrdonnee = list2LDC([0,1,2])
# On crée une liste doublement chainée ordonnée avec doublons
ldcOrdonneeDoublons = list2LDC([0,1,1,2])
# On crée une liste doublement chainée non-ordonnée
ldcNonOrdonnee = list2LDC([0,2,1])
# On crée une liste doublement chainée non-ordonnée avec des doublons
ldcNonOrdonneeDoublons = list2LDC([0,2,1,3,2])
# Pour lever les erreurs d'assertions
# On crée des noeuds pour faire une liste de noeuds
noeud1 = creerNoeudLDC(1,None,None)
noeud2 = creerNoeudLDC(2,None,None)
setSuivantLDC(noeud1,noeud2)
setPrecedentLDC(noeud2,noeud1)
ldcKO = ['string',noeud1,noeud2]
myTestsTitle("triLDC()")
print("ldcOrdonnee : ",ldcOrdonnee)
print("triLDC(ldcOrdonnee) : ",triLDC(ldcOrdonnee))
print(sepSymb("-"))
print("ldcOrdonneedoublons : ",ldcOrdonneeDoublons)
print("triLDC(ldcOrdonneeDoublons) : ",triLDC(ldcOrdonneeDoublons))
print(sepSymb("-"))
print("ldcNonOrdonnee : ",ldcNonOrdonnee)
print("triLDC(ldcNonOrdonnee) : ",triLDC(ldcNonOrdonnee))
print(sepSymb("-"))
print("ldcNonOrdonneeDoublons : ",ldcNonOrdonneeDoublons)
print("triLDC(ldcNonOrdonneeDoublons : ",triLDC(ldcNonOrdonneeDoublons))
# Tests pour lever les erreurs d'assertion
myAssertTestsTitle("triLDC() -> test des assertions")
try:
print(warnString("listeVide ->"+str(listeVide)))
triLDC(listeVide)
except AssertionError as msg:
print(warnString("triLDC(listeVide) ->"),msg)
print(warnString(sepSymb("-")))
try:
print(warnString("ldcKO ->"+str(ldcKO)))
triLDC(ldcKO)
except AssertionError as msg:
print(warnString("triLDC(ldcKO) ->"),msg)
def tests_insereOrdreLDC():
"""Teste la fonction insereOrdreLDC()"""
listeVide = creerListeVide()
# On crée une liste doublement chainée ordonnée
ldcOrdonnee = list2LDC([0,1,2,3,4,5])
# On crée une liste doublement chainée ordonnée avec doublons
ldcOrdonneeDoublons = list2LDC([0,1,1,2,2,2,2,4,6])
# On crée une liste doublement chainée non-ordonnée
ldcNonOrdonnee = list2LDC([0,2,1])
# Pour lever les erreurs d'assertions
# On crée des noeuds pour faire une liste de noeuds
noeud1 = creerNoeudLDC(1,None,None)
noeud2 = creerNoeudLDC(2,None,None)
setSuivantLDC(noeud1,noeud2)
setPrecedentLDC(noeud2,noeud1)
ldcKO = ['string',noeud1,noeud2]
myTestsTitle("insereOrdreLDC()")
print("listeVide : ",listeVide)
listeVide = insereOrdreLDC(listeVide,5)
print("insereOrdreLDC(listeVide,5) : ",listeVide)
print(sepSymb("-"))
print(colorString("Pour la lisibilité des tests suivants, on affiche le tableau des valeurs et non les listes doublement chainées","\033[31m"))
print(sepSymb("-"))
print("ldcOrdonnee : ",LDC2List(ldcOrdonnee))
ldcOrdonnee = insereOrdreLDC(ldcOrdonnee,3)
print("insereOrdreLDC(ldcOrdonnee,3) : ",LDC2List(ldcOrdonnee))
print(sepSymb("-"))
print("ldcOrdonneedoublons : ",LDC2List(ldcOrdonneeDoublons))
ldcOrdonneeDoublons = insereOrdreLDC(ldcOrdonneeDoublons,3)
print("insereOrdreLDC(ldcOrdonneeDoublons,3): ",LDC2List(ldcOrdonneeDoublons))
# Tests pour lever les erreurs d'assertion
myAssertTestsTitle("insereOrdreLDC() -> test des assertions")
try:
print(warnString("ldcOrdonnee ->"+str(LDC2List(ldcOrdonnee))))
insereOrdreLDC(ldcOrdonnee,'foo')
except AssertionError as msg:
print(warnString("insereOrdreLDC(ldcOrdonnee,'foo') ->"),msg)
print(warnString(sepSymb("-")))
try:
print(warnString("ldcNonOrdonnee ->"+str(LDC2List(ldcNonOrdonnee))))
insereOrdreLDC(ldcNonOrdonnee,5)
except AssertionError as msg:
print(warnString("insereOrdreLDC(ldcNonOrdonnee,5) ->"),msg)
print(warnString(sepSymb("-")))
try:
print(warnString("ldcKO ->"+str(ldcKO)))
insereOrdreLDC(ldcKO,5)
except AssertionError as msg:
print(warnString("insereOrdreLDC(ldcKO,5) ->"),msg)
def tests_MainP2():
"""Gère les tests de la partie 2"""
# On récupère la date au début du traitement
start_time = datetime.now()
os.system("clear")
choice = ''
while choice not in ['1','2','3','4']:
os.system("clear")
myTitle("PARTIE 2 - TESTS")
choice = input("""
Quels tests voulez-vous lancer ?
---> 1 : estOrdonneeLDC()
---> 2 : triLDC()
---> 3 : insereOrdreLDC()
---> 4 : Toutes les fonctions
""")
os.system("clear")
myTitle("TESTS FONCTIONS")
if (choice == '1'):
tests_estOrdnneeLDC()
elif (choice == '2'):
tests_triLDC()
elif (choice == '3'):
tests_insereOrdreLDC()
elif (choice == '4'):
tests_estOrdnneeLDC()
tests_triLDC()
tests_insereOrdreLDC()
# On évalue le temps de traitement
end_time = datetime.now()
# On affiche
timeShow(end_time-start_time)
if __name__ == "__main__":
restart = ''
while restart not in ['o','n']:
genericTitle("UN AUTRE TEST ?",'#')
restart = input("Taper o ou n pour relancer le script --> ")
if restart == 'o':
tests_MainP2()
def tests_MainP2New():
"""Gère les tests de la partie 2"""
# On récupère la date au début du traitement
start_time = datetime.now()
os.system("clear")
tests_estOrdnneeLDC()
tests_triLDC()
tests_insereOrdreLDC()
# On évalue le temps de traitement
end_time = datetime.now()
# On affiche
timeShow(end_time-start_time)
if __name__ == "__main__":
#tests_MainP2()
tests_MainP2New()Functions
def estOrdonneeLDC(ldc: list) ‑> bool-
Renvoie True si la liste doublement chainée ldc est croissante au sens large.
Doublons possibles.
Paramètres
* ldc -- liste doublement chainée.Sorties
* Un booléen.Expand source code
def estOrdonneeLDC(ldc:list)->bool: """Renvoie True si la liste doublement chainée **ldc** est croissante au sens large. Doublons possibles. **Paramètres** * ldc -- liste doublement chainée. **Sorties** * Un booléen. """ pass assert (ldc is not None),warnString("La liste est vide, on ne peut pas statuer sur l'ordre de ses élements.") assert (estNoeudLDC(getPrecedentLDC(ldc)) and estNoeudLDC(getSuivantLDC(ldc))) # msg issu de estNoeudLDC myBool = False p = 0 noeud = ldc while (p<longueurLDC(ldc)-1 and getValLDC(noeud)<=getValLDC(getSuivantLDC(noeud))): noeud = getSuivantLDC(noeud) p += 1 if (p == longueurLDC(ldc)-1): myBool = True return myBool def insereOrdreLDC(ldc: list, val: int) ‑> list-
Insère la valeur val à sa place dans la liste doublement chainée ldc croissante, demanière à ce qu'elle reste croissante au sens large.
Doublons possibles.
Paramètres
* ldc -- liste doublement chainée.Sorties
* la liste doublement chainée triée dans l'ordre croissant.Expand source code
def insereOrdreLDC(ldc:list,val:int)->list: """Insère la valeur **val** à sa place dans la liste doublement chainée **ldc** croissante, demanière à ce qu'elle reste croissante au sens large. Doublons possibles. **Paramètres** * ldc -- liste doublement chainée. **Sorties** * la liste doublement chainée triée dans l'ordre croissant. """ pass assert (ldc is None) or estOrdonneeLDC(ldc),warnString(str(LDC2List(ldc))+" devrait être ordonnée") assert (ldc is None) or (estNoeudLDC(getPrecedentLDC(ldc)) and estNoeudLDC(getSuivantLDC(ldc))) # msg issu de estNoeudLDC assert isinstance(val,int),warnString(str(val)+" devrait être un entier") if ldc is None: ldc = [] ldc = creerNoeudLDC(val,None,None) else: i = 0 # pourl'indice courant currentNode = ldc while getValLDC(currentNode)<val: currentNode = getSuivantLDC(currentNode) i += 1 # Quand on sort de la boucle on a l'indice d'insertion insererPlaceLDC(ldc,val,i) return ldc def tests_MainP2()-
Gère les tests de la partie 2
Expand source code
def tests_MainP2(): """Gère les tests de la partie 2""" # On récupère la date au début du traitement start_time = datetime.now() os.system("clear") choice = '' while choice not in ['1','2','3','4']: os.system("clear") myTitle("PARTIE 2 - TESTS") choice = input(""" Quels tests voulez-vous lancer ? ---> 1 : estOrdonneeLDC() ---> 2 : triLDC() ---> 3 : insereOrdreLDC() ---> 4 : Toutes les fonctions """) os.system("clear") myTitle("TESTS FONCTIONS") if (choice == '1'): tests_estOrdnneeLDC() elif (choice == '2'): tests_triLDC() elif (choice == '3'): tests_insereOrdreLDC() elif (choice == '4'): tests_estOrdnneeLDC() tests_triLDC() tests_insereOrdreLDC() # On évalue le temps de traitement end_time = datetime.now() # On affiche timeShow(end_time-start_time) if __name__ == "__main__": restart = '' while restart not in ['o','n']: genericTitle("UN AUTRE TEST ?",'#') restart = input("Taper o ou n pour relancer le script --> ") if restart == 'o': tests_MainP2() def tests_MainP2New()-
Gère les tests de la partie 2
Expand source code
def tests_MainP2New(): """Gère les tests de la partie 2""" # On récupère la date au début du traitement start_time = datetime.now() os.system("clear") tests_estOrdnneeLDC() tests_triLDC() tests_insereOrdreLDC() # On évalue le temps de traitement end_time = datetime.now() # On affiche timeShow(end_time-start_time) def tests_estOrdnneeLDC()-
Teste la fonction estOrdonneeLDC()
Expand source code
def tests_estOrdnneeLDC(): """Teste la fonction estOrdonneeLDC()""" listeVide = creerListeVide() # On crée une liste doublement chainée ordonnée ldcOrdonnee = list2LDC([0,1,2]) # On crée une liste doublement chainée ordonnée avec doublons ldcOrdonneeDoublons = list2LDC([0,1,1,2]) # On crée une liste doublement chainée non-ordonnée ldcNonOrdonnee = list2LDC([0,2,1]) # On crée une liste doublement chainée non-ordonnée avec des doublons ldcNonOrdonneeDoublons = list2LDC([0,2,1,3,2]) # Pour lever les erreurs d'assertions # On crée des noeuds pour faire une liste de noeuds noeud1 = creerNoeudLDC(1,None,None) noeud2 = creerNoeudLDC(2,None,None) setSuivantLDC(noeud1,noeud2) setPrecedentLDC(noeud2,noeud1) ldcKO = ['string',noeud1,noeud2] myTestsTitle("estOrdonneeLDC()") print("ldcOrdonnee : ",ldcOrdonnee) print("estOrdonneeLDC(ldcOrdonnee) : ",estOrdonneeLDC(ldcOrdonnee)) print(sepSymb("-")) print("ldcOrdonneedoublons : ",ldcOrdonneeDoublons) print("estOrdonneeLDC(ldcOrdonneeDoublons) : ",estOrdonneeLDC(ldcOrdonneeDoublons)) print(sepSymb("-")) print("ldcNonOrdonnee : ",ldcNonOrdonnee) print("estOrdonneeLDC(ldcNonOrdonnee) : ",estOrdonneeLDC(ldcNonOrdonnee)) print(sepSymb("-")) print("ldcNonOrdonneeDoublons : ",ldcNonOrdonneeDoublons) print("estOrdonneeLDC(ldcNonOrdonneeDoublons : ",estOrdonneeLDC(ldcNonOrdonneeDoublons)) # Tests pour lever les erreurs d'assertion myAssertTestsTitle("estOrdonneeLDC() -> test des assertions") try: print(warnString("listeVide ->"+str(listeVide))) estOrdonneeLDC(listeVide) except AssertionError as msg: print(warnString("estOrdonneeLDC(listeVide) ->"),msg) print(warnString(sepSymb("-"))) try: print(warnString("ldcKO ->"+str(ldcKO))) estOrdonneeLDC(ldcKO) except AssertionError as msg: print(warnString("estOrdonneeLDC(ldcKO) ->"),msg) def tests_insereOrdreLDC()-
Teste la fonction insereOrdreLDC()
Expand source code
def tests_insereOrdreLDC(): """Teste la fonction insereOrdreLDC()""" listeVide = creerListeVide() # On crée une liste doublement chainée ordonnée ldcOrdonnee = list2LDC([0,1,2,3,4,5]) # On crée une liste doublement chainée ordonnée avec doublons ldcOrdonneeDoublons = list2LDC([0,1,1,2,2,2,2,4,6]) # On crée une liste doublement chainée non-ordonnée ldcNonOrdonnee = list2LDC([0,2,1]) # Pour lever les erreurs d'assertions # On crée des noeuds pour faire une liste de noeuds noeud1 = creerNoeudLDC(1,None,None) noeud2 = creerNoeudLDC(2,None,None) setSuivantLDC(noeud1,noeud2) setPrecedentLDC(noeud2,noeud1) ldcKO = ['string',noeud1,noeud2] myTestsTitle("insereOrdreLDC()") print("listeVide : ",listeVide) listeVide = insereOrdreLDC(listeVide,5) print("insereOrdreLDC(listeVide,5) : ",listeVide) print(sepSymb("-")) print(colorString("Pour la lisibilité des tests suivants, on affiche le tableau des valeurs et non les listes doublement chainées","\033[31m")) print(sepSymb("-")) print("ldcOrdonnee : ",LDC2List(ldcOrdonnee)) ldcOrdonnee = insereOrdreLDC(ldcOrdonnee,3) print("insereOrdreLDC(ldcOrdonnee,3) : ",LDC2List(ldcOrdonnee)) print(sepSymb("-")) print("ldcOrdonneedoublons : ",LDC2List(ldcOrdonneeDoublons)) ldcOrdonneeDoublons = insereOrdreLDC(ldcOrdonneeDoublons,3) print("insereOrdreLDC(ldcOrdonneeDoublons,3): ",LDC2List(ldcOrdonneeDoublons)) # Tests pour lever les erreurs d'assertion myAssertTestsTitle("insereOrdreLDC() -> test des assertions") try: print(warnString("ldcOrdonnee ->"+str(LDC2List(ldcOrdonnee)))) insereOrdreLDC(ldcOrdonnee,'foo') except AssertionError as msg: print(warnString("insereOrdreLDC(ldcOrdonnee,'foo') ->"),msg) print(warnString(sepSymb("-"))) try: print(warnString("ldcNonOrdonnee ->"+str(LDC2List(ldcNonOrdonnee)))) insereOrdreLDC(ldcNonOrdonnee,5) except AssertionError as msg: print(warnString("insereOrdreLDC(ldcNonOrdonnee,5) ->"),msg) print(warnString(sepSymb("-"))) try: print(warnString("ldcKO ->"+str(ldcKO))) insereOrdreLDC(ldcKO,5) except AssertionError as msg: print(warnString("insereOrdreLDC(ldcKO,5) ->"),msg) def tests_triLDC()-
Teste la fonction triLDC()
Expand source code
def tests_triLDC(): """Teste la fonction triLDC()""" listeVide = creerListeVide() # On crée une liste doublement chainée ordonnée ldcOrdonnee = list2LDC([0,1,2]) # On crée une liste doublement chainée ordonnée avec doublons ldcOrdonneeDoublons = list2LDC([0,1,1,2]) # On crée une liste doublement chainée non-ordonnée ldcNonOrdonnee = list2LDC([0,2,1]) # On crée une liste doublement chainée non-ordonnée avec des doublons ldcNonOrdonneeDoublons = list2LDC([0,2,1,3,2]) # Pour lever les erreurs d'assertions # On crée des noeuds pour faire une liste de noeuds noeud1 = creerNoeudLDC(1,None,None) noeud2 = creerNoeudLDC(2,None,None) setSuivantLDC(noeud1,noeud2) setPrecedentLDC(noeud2,noeud1) ldcKO = ['string',noeud1,noeud2] myTestsTitle("triLDC()") print("ldcOrdonnee : ",ldcOrdonnee) print("triLDC(ldcOrdonnee) : ",triLDC(ldcOrdonnee)) print(sepSymb("-")) print("ldcOrdonneedoublons : ",ldcOrdonneeDoublons) print("triLDC(ldcOrdonneeDoublons) : ",triLDC(ldcOrdonneeDoublons)) print(sepSymb("-")) print("ldcNonOrdonnee : ",ldcNonOrdonnee) print("triLDC(ldcNonOrdonnee) : ",triLDC(ldcNonOrdonnee)) print(sepSymb("-")) print("ldcNonOrdonneeDoublons : ",ldcNonOrdonneeDoublons) print("triLDC(ldcNonOrdonneeDoublons : ",triLDC(ldcNonOrdonneeDoublons)) # Tests pour lever les erreurs d'assertion myAssertTestsTitle("triLDC() -> test des assertions") try: print(warnString("listeVide ->"+str(listeVide))) triLDC(listeVide) except AssertionError as msg: print(warnString("triLDC(listeVide) ->"),msg) print(warnString(sepSymb("-"))) try: print(warnString("ldcKO ->"+str(ldcKO))) triLDC(ldcKO) except AssertionError as msg: print(warnString("triLDC(ldcKO) ->"),msg) def triLDC(ldc: list) ‑> list-
Renvoie la liste doublement chainée ldc triée dans l'ordre croissant au sens large.
Doublons possibles.
Paramètres
* ldc -- liste doublement chainée.Sorties
* la liste doublement chainée triée dans l'ordre croissant.Expand source code
def triLDC(ldc:list)->list: """Renvoie la liste doublement chainée **ldc** triée dans l'ordre croissant au sens large. Doublons possibles. **Paramètres** * ldc -- liste doublement chainée. **Sorties** * la liste doublement chainée triée dans l'ordre croissant. """ pass assert (ldc is not None),warnString("La liste est vide, on ne peut pas trier ses élements.") assert (estNoeudLDC(getPrecedentLDC(ldc)) and estNoeudLDC(getSuivantLDC(ldc))) # msg issu de estNoeudLDC # On transforme la liste doublement chainee en liste Python ldc2listPython = LDC2List(ldc) # On trie la liste ldc2listPython.sort() # On retransforme en liste doublement chainée ldc = list2LDC(ldc2listPython) return ldc