Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2021-08-06T10:42:45+02:00Les derniers messages parus sur le forum de Zeste de Savoir.Les listes doublement chaînée, message #2364632021-08-06T10:42:45+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p236463<p>Bonjour entwanne, </p>
<p>finalement j’ai bien réussit hier à corriger les soucis, voici le nouveau code : </p>
<div class="hljs-code-div hljs-code-text"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span><span data-count="29"></span><span data-count="30"></span><span data-count="31"></span><span data-count="32"></span><span data-count="33"></span><span data-count="34"></span><span data-count="35"></span><span data-count="36"></span><span data-count="37"></span><span data-count="38"></span><span data-count="39"></span><span data-count="40"></span><span data-count="41"></span><span data-count="42"></span><span data-count="43"></span><span data-count="44"></span><span data-count="45"></span><span data-count="46"></span><span data-count="47"></span><span data-count="48"></span><span data-count="49"></span><span data-count="50"></span><span data-count="51"></span><span data-count="52"></span><span data-count="53"></span><span data-count="54"></span><span data-count="55"></span><span data-count="56"></span><span data-count="57"></span><span data-count="58"></span><span data-count="59"></span><span data-count="60"></span><span data-count="61"></span><span data-count="62"></span><span data-count="63"></span><span data-count="64"></span><span data-count="65"></span><span data-count="66"></span><span data-count="67"></span><span data-count="68"></span><span data-count="69"></span><span data-count="70"></span><span data-count="71"></span><span data-count="72"></span><span data-count="73"></span><span data-count="74"></span><span data-count="75"></span><span data-count="76"></span><span data-count="77"></span><span data-count="78"></span><span data-count="79"></span><span data-count="80"></span><span data-count="81"></span><span data-count="82"></span><span data-count="83"></span><span data-count="84"></span><span data-count="85"></span><span data-count="86"></span><span data-count="87"></span><span data-count="88"></span><span data-count="89"></span><span data-count="90"></span><span data-count="91"></span><span data-count="92"></span><span data-count="93"></span><span data-count="94"></span><span data-count="95"></span><span data-count="96"></span><span data-count="97"></span><span data-count="98"></span><span data-count="99"></span><span data-count="100"></span><span data-count="101"></span><span data-count="102"></span><span data-count="103"></span><span data-count="104"></span><span data-count="105"></span><span data-count="106"></span><span data-count="107"></span><span data-count="108"></span><span data-count="109"></span><span data-count="110"></span><span data-count="111"></span><span data-count="112"></span><span data-count="113"></span><span data-count="114"></span><span data-count="115"></span><span data-count="116"></span><span data-count="117"></span><span data-count="118"></span><span data-count="119"></span><span data-count="120"></span><span data-count="121"></span><span data-count="122"></span><span data-count="123"></span><span data-count="124"></span><span data-count="125"></span><span data-count="126"></span><span data-count="127"></span><span data-count="128"></span><span data-count="129"></span><span data-count="130"></span><span data-count="131"></span><span data-count="132"></span><span data-count="133"></span><span data-count="134"></span><span data-count="135"></span><span data-count="136"></span><span data-count="137"></span><span data-count="138"></span><span data-count="139"></span><span data-count="140"></span><span data-count="141"></span><span data-count="142"></span><span data-count="143"></span><span data-count="144"></span><span data-count="145"></span><span data-count="146"></span><span data-count="147"></span><span data-count="148"></span><span data-count="149"></span><span data-count="150"></span><span data-count="151"></span><span data-count="152"></span><span data-count="153"></span><span data-count="154"></span><span data-count="155"></span><span data-count="156"></span><span data-count="157"></span><span data-count="158"></span><span data-count="159"></span><span data-count="160"></span><span data-count="161"></span><span data-count="162"></span><span data-count="163"></span><span data-count="164"></span><span data-count="165"></span><span data-count="166"></span><span data-count="167"></span><span data-count="168"></span><span data-count="169"></span><span data-count="170"></span><span data-count="171"></span><span data-count="172"></span><span data-count="173"></span><span data-count="174"></span><span data-count="175"></span><span data-count="176"></span><span data-count="177"></span><span data-count="178"></span><span data-count="179"></span><span data-count="180"></span><span data-count="181"></span><span data-count="182"></span><span data-count="183"></span><span data-count="184"></span><span data-count="185"></span><span data-count="186"></span><span data-count="187"></span><span data-count="188"></span><span data-count="189"></span><span data-count="190"></span><span data-count="191"></span><span data-count="192"></span><span data-count="193"></span><span data-count="194"></span><span data-count="195"></span><span data-count="196"></span><span data-count="197"></span><span data-count="198"></span><span data-count="199"></span><span data-count="200"></span><span data-count="201"></span><span data-count="202"></span><span data-count="203"></span><span data-count="204"></span><span data-count="205"></span><span data-count="206"></span><span data-count="207"></span><span data-count="208"></span><span data-count="209"></span><span data-count="210"></span><span data-count="211"></span><span data-count="212"></span><span data-count="213"></span><span data-count="214"></span><span data-count="215"></span><span data-count="216"></span><span data-count="217"></span><span data-count="218"></span><span data-count="219"></span><span data-count="220"></span><span data-count="221"></span><span data-count="222"></span><span data-count="223"></span><span data-count="224"></span><span data-count="225"></span><span data-count="226"></span><span data-count="227"></span><span data-count="228"></span><span data-count="229"></span><span data-count="230"></span><span data-count="231"></span><span data-count="232"></span><span data-count="233"></span><span data-count="234"></span><span data-count="235"></span><span data-count="236"></span><span data-count="237"></span><span data-count="238"></span><span data-count="239"></span><span data-count="240"></span><span data-count="241"></span><span data-count="242"></span><span data-count="243"></span><span data-count="244"></span><span data-count="245"></span><span data-count="246"></span><span data-count="247"></span><span data-count="248"></span><span data-count="249"></span><span data-count="250"></span><span data-count="251"></span><span data-count="252"></span><span data-count="253"></span><span data-count="254"></span><span data-count="255"></span><span data-count="256"></span><span data-count="257"></span><span data-count="258"></span><span data-count="259"></span><span data-count="260"></span><span data-count="261"></span><span data-count="262"></span><span data-count="263"></span><span data-count="264"></span><span data-count="265"></span><span data-count="266"></span><span data-count="267"></span><span data-count="268"></span><span data-count="269"></span><span data-count="270"></span><span data-count="271"></span><span data-count="272"></span><span data-count="273"></span><span data-count="274"></span><span data-count="275"></span><span data-count="276"></span><span data-count="277"></span><span data-count="278"></span><span data-count="279"></span><span data-count="280"></span><span data-count="281"></span><span data-count="282"></span><span data-count="283"></span><span data-count="284"></span><span data-count="285"></span><span data-count="286"></span><span data-count="287"></span><span data-count="288"></span><span data-count="289"></span><span data-count="290"></span><span data-count="291"></span><span data-count="292"></span><span data-count="293"></span><span data-count="294"></span><span data-count="295"></span><span data-count="296"></span><span data-count="297"></span><span data-count="298"></span><span data-count="299"></span><span data-count="300"></span><span data-count="301"></span><span data-count="302"></span><span data-count="303"></span><span data-count="304"></span><span data-count="305"></span><span data-count="306"></span><span data-count="307"></span><span data-count="308"></span><span data-count="309"></span><span data-count="310"></span><span data-count="311"></span><span data-count="312"></span><span data-count="313"></span><span data-count="314"></span><span data-count="315"></span><span data-count="316"></span><span data-count="317"></span><span data-count="318"></span><span data-count="319"></span><span data-count="320"></span><span data-count="321"></span><span data-count="322"></span><span data-count="323"></span><span data-count="324"></span><span data-count="325"></span><span data-count="326"></span><span data-count="327"></span><span data-count="328"></span><span data-count="329"></span><span data-count="330"></span><span data-count="331"></span><span data-count="332"></span><span data-count="333"></span><span data-count="334"></span><span data-count="335"></span><span data-count="336"></span><span data-count="337"></span><span data-count="338"></span><span data-count="339"></span><span data-count="340"></span><span data-count="341"></span><span data-count="342"></span><span data-count="343"></span><span data-count="344"></span><span data-count="345"></span><span data-count="346"></span><span data-count="347"></span><span data-count="348"></span><span data-count="349"></span><span data-count="350"></span><span data-count="351"></span><span data-count="352"></span><span data-count="353"></span><span data-count="354"></span><span data-count="355"></span><span data-count="356"></span><span data-count="357"></span><span data-count="358"></span><span data-count="359"></span><span data-count="360"></span><span data-count="361"></span><span data-count="362"></span><span data-count="363"></span><span data-count="364"></span><span data-count="365"></span><span data-count="366"></span><span data-count="367"></span><span data-count="368"></span><span data-count="369"></span><span data-count="370"></span><span data-count="371"></span><span data-count="372"></span><span data-count="373"></span><span data-count="374"></span><span data-count="375"></span><span data-count="376"></span><span data-count="377"></span><span data-count="378"></span><span data-count="379"></span><span data-count="380"></span><span data-count="381"></span><span data-count="382"></span><span data-count="383"></span><span data-count="384"></span><span data-count="385"></span><span data-count="386"></span><span data-count="387"></span><span data-count="388"></span><span data-count="389"></span><span data-count="390"></span><span data-count="391"></span><span data-count="392"></span><span data-count="393"></span><span data-count="394"></span><span data-count="395"></span><span data-count="396"></span><span data-count="397"></span><span data-count="398"></span><span data-count="399"></span><span data-count="400"></span><span data-count="401"></span><span data-count="402"></span><span data-count="403"></span><span data-count="404"></span><span data-count="405"></span><span data-count="406"></span><span data-count="407"></span><span data-count="408"></span><span data-count="409"></span><span data-count="410"></span><span data-count="411"></span><span data-count="412"></span><span data-count="413"></span><span data-count="414"></span><span data-count="415"></span><span data-count="416"></span><span data-count="417"></span><span data-count="418"></span><span data-count="419"></span><span data-count="420"></span><span data-count="421"></span><span data-count="422"></span><span data-count="423"></span><span data-count="424"></span><span data-count="425"></span><span data-count="426"></span><span data-count="427"></span><span data-count="428"></span><span data-count="429"></span><span data-count="430"></span><span data-count="431"></span><span data-count="432"></span><span data-count="433"></span><span data-count="434"></span><span data-count="435"></span><span data-count="436"></span><span data-count="437"></span><span data-count="438"></span><span data-count="439"></span><span data-count="440"></span><span data-count="441"></span><span data-count="442"></span><span data-count="443"></span><span data-count="444"></span><span data-count="445"></span><span data-count="446"></span><span data-count="447"></span><span data-count="448"></span><span data-count="449"></span><span data-count="450"></span><span data-count="451"></span><span data-count="452"></span><span data-count="453"></span><span data-count="454"></span><span data-count="455"></span><span data-count="456"></span><span data-count="457"></span><span data-count="458"></span><span data-count="459"></span><span data-count="460"></span><span data-count="461"></span><span data-count="462"></span><span data-count="463"></span><span data-count="464"></span><span data-count="465"></span><span data-count="466"></span><span data-count="467"></span><span data-count="468"></span><span data-count="469"></span><span data-count="470"></span><span data-count="471"></span><span data-count="472"></span><span data-count="473"></span><span data-count="474"></span><span data-count="475"></span><span data-count="476"></span><span data-count="477"></span><span data-count="478"></span><span data-count="479"></span><span data-count="480"></span><span data-count="481"></span><span data-count="482"></span><span data-count="483"></span><span data-count="484"></span><span data-count="485"></span><span data-count="486"></span><span data-count="487"></span><span data-count="488"></span><span data-count="489"></span><span data-count="490"></span><span data-count="491"></span><span data-count="492"></span><span data-count="493"></span><span data-count="494"></span><span data-count="495"></span><span data-count="496"></span><span data-count="497"></span><span data-count="498"></span><span data-count="499"></span><span data-count="500"></span></div><pre><code class="hljs language-text">###################################
##### Implémentation des LDC#######
###################################
def creerListeVide():
"""
Crée une liste vide
:paramètre : None
:return : None
"""
## la liste vide vaut None
return None
def setPrecedent (n, ns):
"""
Mets la liste doublement chainée précendente du noeud dans le noeuds n
:paramètre : n : un noeud
ns : liste doucblement chainée
:return : None
"""
n[1] = ns
def setSuivant (n, ns):
"""
Mets la liste doublement chainée suivante du noeud dans le noeuds n
:paramètre : n : un noeud
ns : liste doucblement chainée suivante
:return : None
"""
n[2] = ns
def creerNoeudLDC(val, precedent, suivant):
"""
Crée un noeud (une liste Python de trois cases) [valeur, noeud présecéent, noeud suivant]
:paramètre : val : valeur du noeud
precedent : contient les noeuds précédent le noeud courant, None si pas de noeud précédent
suivant : contient les noeuds suivant le noeud courant, None si pas de noeud suivant
:return : noeud sous la forme [valeur, noeud présecéent, noeud suivant]
"""
if precedent == None and suivant != None:
return [val, None, suivant]
if precedent != None and suivant == None:
return [val, precedent, None]
if precedent != None and suivant != None:
return [val, precedent, suivant]
else :
return [val, None, None]
def EstNoeudLDC_Precedent(n):
"""
"""
pass
assert (n == None) or (isinstance(n, list) and len(n) == 3 and EstNoeudLDC_Precedent(n[1])) ## Devrait être None ou une liste de 3 éléments [entier, noeudLDC ou None, noeudLDC ou None]
return True
def EstNoeudLDC_Suivant(n):
"""
"""
pass
assert (n == None) or (isinstance(n,list) and len(n)==3 and EstNoeudLDC_Suivant(n[2])) ## Devrait être None ou une liste de 3 éléments [entier, noeudLDC ou None, noeudLDC ou None]
return True
def EstNoeudLDC(n):
"""
"""
pass
assert (n == None) or (EstNoeudLDC_Precedent(n) and EstNoeudLDC_Suivant(n)) ## Devrait être None ou une liste de 3 éléments [entier, noeudLDC ou None, noeudLDC ou None]
return True
def GetValLDC(n):
"""
Permet d'obtenir la valeur du noeud
:paramètre : n : un noeud
:return : la valeur du noeud
"""
assert(n != None) ## on ne peut pas obtenir la valeur d'une liste vide
assert (EstNoeudLDC(n)) ## Doit être un noeud
return n[0]
def GetSuivantLDC(n):
"""
Permet d'obtenir la liste des noeuds suivant
:paramètre : n : un noeud
:return : la liste des noeuds suivant
"""
assert(n != None) ## on ne peut pas obtenir la noeud suivant sur une liste vide
assert (EstNoeudLDC(n)) ## Doit être un noeud
return n[2]
def GetPrecedentLDC(n):
"""
Permet d'obtenir la liste des noeuds précédent
:paramètre : n : un noeud
:return : la liste des noeuds précédent
"""
assert(n != None) ## on ne peut pas obtenir la noeud précédent sur une liste vide
assert (EstNoeudLDC(n)) ## Doit être un noeud
return n[1]
def LongueurLDC(l):
"""
Permet d'obtenir la longeur de la liste doublement chainée
:paramètre : l : liste doublement chainée
:return : int : la valeur de la longeur de la liste
"""
lg = 0
n = l
if l is None :
return lg
else :
lg = 1
while n[2] != None:
lg += 1
n = GetSuivantLDC(n)
return lg
def InsererDebutLDC(l,val):
"""
Permet d'inserer une valeur en début de liste doublement chainée
:paramètre : l : liste doublement chainée
val : valeur du noeud
:return : nn : la nouvelle liste chainée
"""
if l is None:
return creerNoeudLDC(val, None, None)
else:
n = l
while GetPrecedentLDC(n) != None :
n = GetPrecedentLDC(n)
nn = creerNoeudLDC(val, None, n) # l pointe vers le 1er et non vers la tête de la LDC ?
setPrecedent (n,nn)
return nn
def InsererFinLDC(l,val):
"""
Permet d'inserer une valeur en fin de liste doublement chainée
:paramètre : l : liste doublement chainée
val : valeur du noeud
:return : l : la nouvelle liste chainée
"""
if l is None:
return creerNoeudLDC(val, None, None)
else:
## on parcoure la liste jusqu'à atteindre le dernier noeud
n = l
while GetSuivantLDC(n) != None:
n = GetSuivantLDC(n)
## on met à jour le noeud suivant
n[2] = creerNoeudLDC(val, n, None)
m = GetSuivantLDC(l)
p = GetPrecedentLDC(l)
if p != None :
setPrecedent (n, m)
return l
def SupprimerDebutLDC(l):
"""
Permet de supprimer le premier noeud de la liste doublement chainée
:paramètre : l : liste doublement chainée
:return : n : la nouvelle liste chainée
"""
assert(l != None) ## on ne peut pas supprimer un noeud dans une liste vide
n = l
if LongueurLDC(l) == 1:
return None
else :
n = GetSuivantLDC(n)
n[1] = None
return n
def SupprimerFinLDC(l):
"""
Permet de supprimer le dernier noeud de la liste doublement chainée
:paramètre : l : liste doublement chainée
:return : l : la nouvelle liste chainée
"""
assert(l != None) ## on ne peut pas supprimer un noeud dans une liste vide
n = l
if LongueurLDC(l) == 1:
return None
else :
while GetSuivantLDC(n) != None:
n = GetSuivantLDC(n)
setSuivant (GetPrecedentLDC(n), None)
setPrecedent (n, None)
return l
def AccesLDC(l,p):
"""
Permet d'accéder au noeud d'indice p dans la liste doublement chainée l
:paramètre : l : liste doublement chainée
p : int : indice du noeud souhaiter
:return : liste : une liste de 3 éléments avec [la valeur du noeud, noeuds précédents, noeuds suivants]
"""
assert(l != None) ## on ne peut pas accéder à un noeud dans une liste vide
assert p <= LongueurLDC(l) ##L'indice auqu'elle vous souhaitez accéder est trop grand par rapport à la liste
j = 0
m = l
while j < p:
j +=1
m = GetSuivantLDC(m)
return [m[0],m[1],m[2]]
def InsererPlaceLDC(l,val,p):
"""
Permet d'inserer une valeur à la postion p dans la liste doublement chainée l
:paramètre : l : liste doublement chainée
val : valeur du noeud
p : int : indice du noeud souhaiter
:return : l : la nouvelle liste chainée
"""
assert p <= LongueurLDC(l) ##L'indice donnée pour placer la valeur est trop grand par rapport à la liste
if l is None:
return creerNoeudLDC(val, None, None)
elif p == 0 :
InsererDebutLDC(l,val)
elif p == LongueurLDC(l) :
InsererFinLDC(l,val)
else:
j = 0
m = l
while j < p:
j +=1
m = GetSuivantLDC(m)
n = GetPrecedentLDC(m)
nn = creerNoeudLDC(val, m[1], m)
m[1] = nn
n[2] = m[1]
return l
def SupprimerPlaceLDC(l,p):
"""
Permet de supprimer le noeud d'indice p dans la liste doublement chainée l
:paramètre : l : liste doublement chainée
p : int : indice du noeud souhaiter
:return : l : la nouvelle liste chainée
"""
assert(l != None) ## on ne peut pas supprimer à un noeud dans une liste vide
assert p <= (LongueurLDC(l)-1) ##L'indice auqu'elle vous souhaitez supprimer la valeur est trop grand par rapport à la liste
m = l
if p == 0 :
m = SupprimerDebutLDC(l)
elif p == LongueurLDC(l)-1 :
m = SupprimerFinLDC(l)
else:
j = 0
while j < p:
j +=1
m = GetSuivantLDC(m)
n = GetPrecedentLDC(m)
GetSuivantLDC(m)[1] = m[1]
GetPrecedentLDC(m)[2] = m[2]
m[1] = None
m[2] = None
return l
def SupprimerValLDC(l,val):
"""
Permet de supprimer le premier noeud de valeur val dans la liste doublement chainée l
:paramètre : l : liste doublement chainée
val : valeur du noeud à supprimer
:return : n : la nouvelle liste chainée
"""
assert(l != None) ## on ne peut pas supprimer à un noeud dans une liste vide
n = l
j = 0
while GetValLDC(n) != val:
n = GetSuivantLDC(n)
assert(n != None)## la valeur donnée ne ce trouve pas dans la liste
j +=1
n = SupprimerPlaceLDC(l,j)
return n
def LDC2List(l):
"""
Permet de convertir la liste doublement chainée en une liste qui contient toute les valeurs des noeuds
:paramètre : l : liste doublement chainée
:return : List : la liste qui contient toute les valeurs de LDC
"""
long = LongueurLDC(l)
n = l
j = 0
List = []
while j < long :
List.append(GetValLDC(n))
n = GetSuivantLDC(n)
j += 1
return List
def List2LDC(l):
"""
Permet de convertir la liste qui contient la valeurs des noeuds en une liste doublement chainée
:paramètre : l : la liste qui contient toute les valeurs de LDC
:return : list : liste doublement chainée
"""
if l != None :
list = None
for i in range (len(l)) :
list = InsererFinLDC(list, l[i])
else :
assert () ## Ce n'est pas une liste !
return list
#################################
##### Fonction de Test des LDC###
#################################
def est_vide(l):
"""
Permet de testé si une liste l et vide ou non
:paramètre : l : une liste doublement chainée
:return : bool : True si la liste est vide et False si la liste n'est pas vide.
"""
if LongueurLDC(l) == 0:
return True
else :
return False
def test_creation_liste():
"""
Test du Cosntructeur de la liste doublement chainée
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
assert est_vide(ma_liste)
return True
def test_ajout_tete():
"""
Test de l'ajout d'une valeur en tête de la liste
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 28)
assert not est_vide(ma_liste)
assert LongueurLDC(ma_liste) == 1
return True
def test_ajout_tete_a_fin():
"""
Test de l'ajout d'une valeur en fin de la liste
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererFinLDC(ma_liste, 12)
assert LongueurLDC(ma_liste) == 3
return True
##def test_acces_LDC():
## ma_liste = creerListeVide()
## ma_liste = InsererDebutLDC(ma_liste, 32)
## ma_liste = InsererDebutLDC(ma_liste, 14)
## ma_liste = InsererFinLDC(ma_liste, 12)
## Noeud_1 = AccesLDC(ma_liste, 1)
def test_supression_debut():
"""
Test de supression de la tête de la LDC
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererFinLDC(ma_liste, 12)
ma_liste = SupprimerDebutLDC(ma_liste) # La LDC est 14, 32, 12
assert LongueurLDC(ma_liste) == 2
assert AccesLDC(ma_liste, 0)[0] == 32
return True
def test_supression_fin():
"""
Test de supression de la fin de la LDC
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste,32)
ma_liste = InsererDebutLDC(ma_liste,14)
ma_liste = InsererFinLDC(ma_liste,12)
ma_liste = SupprimerFinLDC(ma_liste) # La LDC est 14, 32, 12
assert LongueurLDC(ma_liste) == 2
assert AccesLDC(ma_liste, 2)[0] == 32
return True
def test_ajout_place(val,p):
"""
Test d'ajout une valeur à la place p
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererFinLDC(ma_liste, 12)
ma_liste = InsererPlaceLDC(ma_liste, val, p) # La LDC est 14, 32, 12,42
assert LongueurLDC(ma_liste) == 4
assert AccesLDC(ma_liste, p)[0] == val
return True
def test_supression_place():
"""
Test de supression d'un noeud à une place définit
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererDebutLDC(ma_liste, 66)
ma_liste = InsererDebutLDC(ma_liste, 33)
ma_liste = SupprimerPlaceLDC(ma_liste, 2) # La LDC est 33, 66, 14, 32 ici on souhiate supprimer 14 le
assert LongueurLDC(ma_liste) == 3
assert AccesLDC(ma_liste, 2)[0] == 32
return True
def test_supression_valeur():
"""
Test de supression d'une valeur dans la LDC
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererDebutLDC(ma_liste, 66)
ma_liste = InsererDebutLDC(ma_liste, 33)
ma_liste = SupprimerValLDC(ma_liste, 14) # La LDC est 33, 66, 14, 32 ici on souhiate supprimer 14
assert LongueurLDC(ma_liste) == 3
assert AccesLDC(ma_liste, 2)[0] == 32
return True
def test_LDC_To_List():
"""
Test de Conversion de la LDC en List
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererDebutLDC(ma_liste, 66)
ma_liste = InsererDebutLDC(ma_liste, 33)
ma_liste = LDC2List(ma_liste) # La LDC est 33, 66, 14, 32 ici on souhaite la convertir le List [33, 66, 14, 32]
assert ma_liste == [33, 66, 14, 32]
return True
def test_List_To_LDC():
"""
Test de la conversion de la List en LDC
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererDebutLDC(ma_liste, 66)
ma_liste = InsererDebutLDC(ma_liste, 33)
ma_liste_test = [33, 66, 14, 32]
ma_liste_test = List2LDC(ma_liste_test)
print("Ma liste : ", ma_liste)
print("Ma liste test : ", ma_liste_test) # La liste est [33, 66, 14, 32] ici on souhiate supprimer 14
assert LongueurLDC(ma_liste_test) == LongueurLDC(ma_liste)
for i in range (LongueurLDC(ma_liste_test)):
assert AccesLDC(ma_liste_test,i) == AccesLDC(ma_liste,i)
return True
##############################################
##### Programme de test des fonction #########
##############################################
if __name__ == '__main__':
print('Test liste vide :', test_creation_liste())
print('Test ajout tête :', test_ajout_tete())
print('Test ajout fin :', test_ajout_tete_a_fin())
print('Test supression début :', test_supression_debut())
print('Test supression fin :', test_supression_debut())
print('Test ajouter à la place :', test_ajout_place(422,2))
print('Test supression Place :', test_supression_place())
print('Test supression Valeur :', test_supression_valeur())
print('Test conversion en List :', test_LDC_To_List())
print('Test conversion en LDC :', test_List_To_LDC())
## print('Test liste acces :', test_acces_LDC())
</code></pre></div>
<p>J’en suis maintenant à essayer les jeux de test pour les fonctions.
Pour test_acces_LDC() j’ai cette erreur : </p>
<div class="hljs-code-div hljs-code-text"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span></div><pre><code class="hljs language-text">Traceback (most recent call last):
File "C:\Users\Julie\Downloads\Projet david bloc 3\Fonction_LDC.py", line 511, in <module>
print('Test conversion en LDC :', test_List_To_LDC())
File "C:\Users\Julie\Downloads\Projet david bloc 3\Fonction_LDC.py", line 493, in test_List_To_LDC
assert AccesLDC(ma_liste_test,i) == AccesLDC(ma_liste,i)
RecursionError: maximum recursion depth exceeded in comparison
</code></pre></div>
<p>Mais je ne voit pas comment faire autrement pour automatiser le test ? a moins de l’afficher à l’utilisateur ? </p>
<p>Bonne journée.
Lesnox</p>Les listes doublement chaînée, message #2364622021-08-06T10:36:04+02:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p236462<figure><blockquote>
<p>voilà où j’en suis, j’ai un soucis avec deux fonction, la fonction SupprimerPlaceLDC(l,p), je ne n’arrive pas à comprendre comment supprimer le nœud quand il est au milieu de la liste.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p236448">lesnox</a></figcaption></figure>
<p>Déjà je ne pense pas qu’il soit utile de calculer la taille de la liste, ça te fait parcourir entièrement al liste pour rien (la taille dans ton cas n’étant pas une donnée connue mais demandant à être calculée).</p>
<p>Ensuite, le principe de la suppression d’un élément, c’est de localiser l’élément qui le précède et celui qui le suit pour les lier entre-eux, faisant ainsi sauter ton maillon.
Il faut donc faire la liaison dans les deux sens.</p>
<p>Aussi, là tu calcules un maillon <code>n</code> à chaque tour de boucle que tu n’utilises pas. Et qui correspond juste à la précédente valeur de <code>m</code>.
C’est noms ne sont d’ailleurs pas très explicites et nuisent à la lisibilité de ton code.</p>
<figure><blockquote>
<p>De même pour la fonction SupprimerValLDC(l,val), si l’utilisateur rentre une valeur qui n’est pas dasn la liste je vais sortir avec un assert mais pas le bon et je voudrait d’abord vérifier que la valeur val est bien dans la liste doublement chainée.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p236448">lesnox</a></figcaption></figure>
<p>C’est exactement le même principe que <code>SupprimerPlaceLDC</code> sauf que tu ne repères pas un élément par rapport à sa position mais par sa valeur.
Il te faut donc parcourir tous les éléments de ta liste et t’arrêter quand tu trouves la bonne valeur.</p>
<p>Si tu as parcouru tous les éléments sans trouver la valeur, alors elle n’est pas dans la liste.
Le problème est que la condition de fin de ta boucle n’est pas bonne puisqu’elle ne t’empêche pas d’aller au-delà de la liste.</p>Les listes doublement chaînée, message #2364482021-08-04T22:41:39+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p236448<p>Bonjour à tous, </p>
<p>voilà où j’en suis, j’ai un soucis avec deux fonction, la fonction SupprimerPlaceLDC(l,p), je ne n’arrive pas à comprendre comment supprimer le nœud quand il est au milieu de la liste.</p>
<p>De même pour la fonction SupprimerValLDC(l,val), si l’utilisateur rentre une valeur qui n’est pas dasn la liste je vais sortir avec un assert mais pas le bon et je voudrait d’abord vérifier que la valeur val est bien dans la liste doublement chainée.</p>
<p>Merci d’avance de votre aide.
Lesnox</p>
<div class="hljs-code-div hljs-code-text"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span><span data-count="29"></span><span data-count="30"></span><span data-count="31"></span><span data-count="32"></span><span data-count="33"></span><span data-count="34"></span><span data-count="35"></span><span data-count="36"></span><span data-count="37"></span><span data-count="38"></span><span data-count="39"></span><span data-count="40"></span><span data-count="41"></span><span data-count="42"></span><span data-count="43"></span><span data-count="44"></span><span data-count="45"></span><span data-count="46"></span><span data-count="47"></span><span data-count="48"></span><span data-count="49"></span><span data-count="50"></span><span data-count="51"></span><span data-count="52"></span><span data-count="53"></span><span data-count="54"></span><span data-count="55"></span><span data-count="56"></span><span data-count="57"></span><span data-count="58"></span><span data-count="59"></span><span data-count="60"></span><span data-count="61"></span><span data-count="62"></span><span data-count="63"></span><span data-count="64"></span><span data-count="65"></span><span data-count="66"></span><span data-count="67"></span><span data-count="68"></span><span data-count="69"></span><span data-count="70"></span><span data-count="71"></span><span data-count="72"></span><span data-count="73"></span><span data-count="74"></span><span data-count="75"></span><span data-count="76"></span><span data-count="77"></span><span data-count="78"></span><span data-count="79"></span><span data-count="80"></span><span data-count="81"></span><span data-count="82"></span><span data-count="83"></span><span data-count="84"></span><span data-count="85"></span><span data-count="86"></span><span data-count="87"></span><span data-count="88"></span><span data-count="89"></span><span data-count="90"></span><span data-count="91"></span><span data-count="92"></span><span data-count="93"></span><span data-count="94"></span><span data-count="95"></span><span data-count="96"></span><span data-count="97"></span><span data-count="98"></span><span data-count="99"></span><span data-count="100"></span><span data-count="101"></span><span data-count="102"></span><span data-count="103"></span><span data-count="104"></span><span data-count="105"></span><span data-count="106"></span><span data-count="107"></span><span data-count="108"></span><span data-count="109"></span><span data-count="110"></span><span data-count="111"></span><span data-count="112"></span><span data-count="113"></span><span data-count="114"></span><span data-count="115"></span><span data-count="116"></span><span data-count="117"></span><span data-count="118"></span><span data-count="119"></span><span data-count="120"></span><span data-count="121"></span><span data-count="122"></span><span data-count="123"></span><span data-count="124"></span><span data-count="125"></span><span data-count="126"></span><span data-count="127"></span><span data-count="128"></span><span data-count="129"></span><span data-count="130"></span><span data-count="131"></span><span data-count="132"></span><span data-count="133"></span><span data-count="134"></span><span data-count="135"></span><span data-count="136"></span><span data-count="137"></span><span data-count="138"></span><span data-count="139"></span><span data-count="140"></span><span data-count="141"></span><span data-count="142"></span><span data-count="143"></span><span data-count="144"></span><span data-count="145"></span><span data-count="146"></span><span data-count="147"></span><span data-count="148"></span><span data-count="149"></span><span data-count="150"></span><span data-count="151"></span><span data-count="152"></span><span data-count="153"></span><span data-count="154"></span><span data-count="155"></span><span data-count="156"></span><span data-count="157"></span><span data-count="158"></span><span data-count="159"></span><span data-count="160"></span><span data-count="161"></span><span data-count="162"></span><span data-count="163"></span><span data-count="164"></span><span data-count="165"></span><span data-count="166"></span><span data-count="167"></span><span data-count="168"></span><span data-count="169"></span><span data-count="170"></span><span data-count="171"></span><span data-count="172"></span><span data-count="173"></span><span data-count="174"></span><span data-count="175"></span><span data-count="176"></span><span data-count="177"></span><span data-count="178"></span><span data-count="179"></span><span data-count="180"></span><span data-count="181"></span><span data-count="182"></span><span data-count="183"></span><span data-count="184"></span><span data-count="185"></span><span data-count="186"></span><span data-count="187"></span><span data-count="188"></span><span data-count="189"></span><span data-count="190"></span><span data-count="191"></span><span data-count="192"></span><span data-count="193"></span><span data-count="194"></span><span data-count="195"></span><span data-count="196"></span><span data-count="197"></span><span data-count="198"></span><span data-count="199"></span><span data-count="200"></span><span data-count="201"></span><span data-count="202"></span><span data-count="203"></span><span data-count="204"></span><span data-count="205"></span><span data-count="206"></span><span data-count="207"></span><span data-count="208"></span><span data-count="209"></span><span data-count="210"></span><span data-count="211"></span><span data-count="212"></span><span data-count="213"></span><span data-count="214"></span><span data-count="215"></span><span data-count="216"></span><span data-count="217"></span><span data-count="218"></span><span data-count="219"></span><span data-count="220"></span><span data-count="221"></span><span data-count="222"></span><span data-count="223"></span><span data-count="224"></span><span data-count="225"></span><span data-count="226"></span><span data-count="227"></span><span data-count="228"></span><span data-count="229"></span><span data-count="230"></span><span data-count="231"></span><span data-count="232"></span><span data-count="233"></span><span data-count="234"></span><span data-count="235"></span><span data-count="236"></span><span data-count="237"></span><span data-count="238"></span><span data-count="239"></span><span data-count="240"></span><span data-count="241"></span><span data-count="242"></span><span data-count="243"></span><span data-count="244"></span><span data-count="245"></span><span data-count="246"></span><span data-count="247"></span><span data-count="248"></span><span data-count="249"></span><span data-count="250"></span><span data-count="251"></span><span data-count="252"></span></div><pre><code class="hljs language-text">###################################
##### Implémentation des LDC#######
###################################
def creerListeVide():
"""
"""
## la liste vide vaut None
return None
def setPrecedent (n, ns):
"""
"""
n[1] = ns
def setSuivant (n, ns):
"""
"""
n[2] = ns
def creerNoeudLDC(val, precedent, suivant):
""" un noeud est une liste Python de trois cases [valeur,noeud présecéent, noeud suivant]
"""
if precedent == None and suivant != None:
return [val, None, suivant]
if precedent != None and suivant == None:
return [val, precedent, None]
if precedent != None and suivant != None:
return [val, precedent, suivant]
else :
return [val, None, None]
def EstNoeudLDC(n):
"""
"""
if n == None:
return True
if (isinstance(n[0], int) == True and isinstance(EstNoeudLDC(n[1]), True) == True and isinstance(EstNoeudLDC(n[2]), True) == True):
return True
else :
return False
def GetValLDC(n):
"""
"""
assert(n != None) ## on ne peut pas obtenir la valeur d'une liste vide
return n[0]
def GetSuivantLDC(n):
"""
"""
assert(n != None) ## on ne peut pas obtenir la noeud suivant sur une liste vide
return n[2]
def GetPrecedentLDC(n):
"""
"""
assert(n != None) ## on ne peut pas obtenir la noeud précédent sur une liste vide
return n[1]
def LongueurLDC(l):
"""
"""
lg = 0
n = l
if l == None :
return lg
else :
lg = 1
while n[2] != None:
lg += 1
n = GetSuivantLDC(n)
return lg
def InsererDebutLDC(l,val):
"""
"""
if l == None:
return creerNoeudLDC(val, None, None)
else:
n = l
while GetPrecedentLDC(n) != None :
n = GetPrecedentLDC(n)
nn = creerNoeudLDC(val, None, n) # l pointe vers le 1er et non vers la tête de la LDC ?
setPrecedent (n,nn)
return nn
def InsererFinLDC(l,val):
"""
"""
if l == None:
return creerNoeudLDC(val, None, None)
else:
## on parcoure la liste jusqu'à atteindre le dernier noeud
n = l
while GetSuivantLDC(n) != None:
n = GetSuivantLDC(n)
## on met à jour le noeud suivant
n[2] = creerNoeudLDC(val, n, None)
m = GetSuivantLDC(l)
p = GetPrecedentLDC(l)
if p != None :
setPrecedent (n, m)
return l
def SupprimerDebutLDC(l):
"""
"""
assert(l != None) ## on ne peut pas supprimer un noeud dans une liste vide
n = l
print ("la liste n est : ", n)
n = GetSuivantLDC(n)
n[1] = None
return n
def SupprimerFinLDC(l):
"""
"""
assert(l != None) ## on ne peut pas supprimer un noeud dans une liste vide
n = l
while GetSuivantLDC(n) != None:
n = GetSuivantLDC(n)
setSuivant (GetPrecedentLDC(n), None)
setPrecedent (n, None)
return l
def AccesLDC(l,p):
"""
"""
assert(l != None) ## on ne peut pas accéder à un noeud dans une liste vide
assert p <= LongueurLDC(l) ##L'indice auqu'elle vous souhaitez accéder est trop grand par rapport à la liste
j = 0
m = l
while j < p:
j +=1
m = GetSuivantLDC(m)
return [m[0],m[1],m[2]]
def InsererPlaceLDC(l,val,p):
"""
"""
assert p <= LongueurLDC(l) ##L'indice donnée pour placer la valeur est trop grand par rapport à la liste
if l == None:
return creerNoeudLDC(val, None, None)
elif p == 0 :
InsererDebutLDC(l,val)
elif p == LongueurLDC(l) :
InsererFinLDC(l,val)
else:
j = 0
m = l
while j < p:
j +=1
m = GetSuivantLDC(m)
n = GetPrecedentLDC(m)
nn = creerNoeudLDC(val, m[1], m)
m[1] = nn
n[2] = m[1]
return l
def SupprimerPlaceLDC(l,p):
"""
"""
assert(l != None) ## on ne peut pas supprimer à un noeud dans une liste vide
assert p <= (LongueurLDC(l)-1) ##L'indice auqu'elle vous souhaitez supprimer la valeur est trop grand par rapport à la liste
m = l
if p == 0 :
m = SupprimerDebutLDC(l)
elif p == LongueurLDC(l)-1 :
m = SupprimerFinLDC(l)
else:
j = 0
while j < p:
j +=1
m = GetSuivantLDC(m)
n = GetPrecedentLDC(m)
print ("j vaut : ", j)
print("n est : ",m)
print("m est : ",GetPrecedentLDC(m))
setPrecedent(GetPrecedentLDC(m),GetSuivantLDC(m))
print("m''' est : ",m)
m[1] = None
m[2] = None
print("l'' vaut : ",m)
return m
##
##def SupprimerValLDC(l,val):
## """
## """
## assert(l != None) ## on ne peut pas supprimer à un noeud dans une liste vide
## n = l
## j = 0
## print(n)
## for i in range (LongueurLDC(l)):
## print(n)
## GetValLDC(n) == val :
## SupprimerPlaceLDC(l,i)
## else :
## assert(i == LongueurLDC(l)) ## La valeur que l'on souhaite supprimer ne ce trouve pas dans la liste.
## return l
def SupprimerValLDC(l,val):
assert(l != None) ## on ne peut pas supprimer à un noeud dans une liste vide
n = l
j = 0
print("la longeur de la lsite est : ", LongueurLDC(l))
while GetValLDC(n) != val:
n = GetSuivantLDC(n)
j +=1
print ("j vaut : ",j)
print("j vaut : ",j)
n = SupprimerPlaceLDC(l,j)
print("n' est : ", n)
return n
def LDC2List(l):
long = LongueurLDC(l)
n = l
j = 0
List = []
while j <= long :
List.append(GetValLDC(n))
n = GetSuivantLDC(n)
j += 1
return List
def List2LDC(l):
if l != None :
list = None
for i in range (len(l)) :
list = InsererFinLDC(list,l[i])
elif l == None :
return None
return list
l = creerListeVide()
l = InsererDebutLDC(l,28)
l = InsererDebutLDC(l,16)
l = InsererDebutLDC(l,23)
l = InsererFinLDC(l,100)
l = InsererPlaceLDC(l,44,2)
print(l)
l = SupprimerValLDC(l,44)
print(l)
</code></pre></div>Les listes doublement chaînée, message #2351582021-06-10T12:49:42+02:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235158<p>Pour créer la liaison il faut identifier le nœud précédent : normalement tu le connais puisque tu as une liste double chaînée et que tu sais où tu insères ton maillon.</p>
<p>Donc tu peux faire pointer la liaison <code>next</code> du maillon précédent sur le nouveau maillon, et la liaison <code>prev</code> sur maillon suivant sur le nouveau maillon aussi.
Puis bien sûr faire pointer les liaisons <code>prev</code> et <code>next</code> de ce nouveau maillon vers les deux autres.</p>
<p>Essaie de prendre un papier et de faire des schémas, ça peut beaucoup aider.</p>Les listes doublement chaînée, message #2351522021-06-10T11:20:24+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235152<figure><blockquote>
<p>Comment faire quoi plus précisément ? Les fonctions manquantes ?</p>
<p>Je pense que tu pourrais déjà retravailler et simplifier ton code existant :</p>
<ul>
<li>les <code>== True</code> dans les conditions sont inutiles, une expression booléenne s’évalue déjà à <code>True</code> ou <code>False</code></li>
<li>pour comparer un objet avec <code>None</code> on utilisera l’opérateur <code>is</code> (test d’identité) plutôt que <code>==</code> (test d’égalité)</li>
<li>ta fonction <code>creerNoeudLDC</code> peut être grandement simplifiée puisque tout ce qu’elle fait se résumé en <code>return [val, precedent, suivant]</code>. Par contre ne devrait-elle pas s’occuper aussi de créer les liaisons avec les nœuds voisins ?</li>
</ul>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235084">entwanne</a></figcaption></figure>
<p>Bonjour <a href="/membres/voir/entwanne/" rel="nofollow" class="ping ping-link">@<span class="ping-username">entwanne</span></a>, </p>
<p>En effet si mais c’est la que j’ai un soucis de compréhension sur comment faire cette liaisons ? </p>
<p>Merci.
Lesnox
Lesnox</p>Les listes doublement chaînée, message #2351502021-06-10T10:48:30+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235150<p>Bonjour <a href="/membres/voir/kayou/" rel="nofollow" class="ping ping-link">@<span class="ping-username">kayou</span></a>, </p>
<p>voici le code que j’ai mis en place pour les listes chaînée : </p>
<div class="hljs-code-div hljs-code-python"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span><span data-count="29"></span><span data-count="30"></span><span data-count="31"></span><span data-count="32"></span><span data-count="33"></span><span data-count="34"></span><span data-count="35"></span><span data-count="36"></span><span data-count="37"></span><span data-count="38"></span><span data-count="39"></span><span data-count="40"></span><span data-count="41"></span><span data-count="42"></span><span data-count="43"></span><span data-count="44"></span><span data-count="45"></span><span data-count="46"></span><span data-count="47"></span><span data-count="48"></span><span data-count="49"></span><span data-count="50"></span><span data-count="51"></span><span data-count="52"></span><span data-count="53"></span><span data-count="54"></span><span data-count="55"></span><span data-count="56"></span><span data-count="57"></span><span data-count="58"></span><span data-count="59"></span><span data-count="60"></span><span data-count="61"></span><span data-count="62"></span><span data-count="63"></span><span data-count="64"></span><span data-count="65"></span><span data-count="66"></span><span data-count="67"></span><span data-count="68"></span><span data-count="69"></span><span data-count="70"></span><span data-count="71"></span><span data-count="72"></span><span data-count="73"></span><span data-count="74"></span><span data-count="75"></span><span data-count="76"></span><span data-count="77"></span><span data-count="78"></span><span data-count="79"></span></div><pre><code class="hljs language-python"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">creerNoeud</span>(<span class="hljs-params">val,suivant</span>):</span>
<span class="hljs-comment">## un noeud est une liste Python de deux cases [valeur,noueud suivant] """</span>
<span class="hljs-keyword">return</span> [val,suivant]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">creerListeVide</span>():</span>
<span class="hljs-comment">## la liste vide vaut None </span>
<span class="hljs-keyword">return</span> <span class="hljs-literal">None</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">tete</span>(<span class="hljs-params">l</span>):</span>
<span class="hljs-keyword">assert</span>(l != <span class="hljs-literal">None</span>) <span class="hljs-comment">## on ne peut pas obtenir la tete d'une liste videe</span>
<span class="hljs-keyword">return</span> l[<span class="hljs-number">0</span>]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">suivant</span>(<span class="hljs-params">l</span>):</span>
<span class="hljs-keyword">assert</span>(l != <span class="hljs-literal">None</span>) <span class="hljs-comment">## on ne peut pas obtenir la noeud suivant sur une liste vide</span>
<span class="hljs-keyword">return</span> l[<span class="hljs-number">1</span>]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">setSuivant</span>(<span class="hljs-params">n,ns</span>):</span>
n[<span class="hljs-number">1</span>] = ns
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">ajouterDebut</span>(<span class="hljs-params">l,val</span>):</span>
<span class="hljs-keyword">if</span> l == <span class="hljs-literal">None</span>:
<span class="hljs-keyword">return</span> creerNoeud(val,<span class="hljs-literal">None</span>)
<span class="hljs-keyword">else</span>:
<span class="hljs-keyword">return</span> creerNoeud(val,l)
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">ajouterFin</span>(<span class="hljs-params">l,val</span>):</span>
<span class="hljs-keyword">if</span> l == <span class="hljs-literal">None</span>:
<span class="hljs-keyword">return</span> creerNoeud(val,<span class="hljs-literal">None</span>)
<span class="hljs-keyword">else</span>:
<span class="hljs-comment">## on parcoure la liste jusqu'à atteindre le dernier noeud</span>
n = l
<span class="hljs-keyword">while</span> suivant(n) != <span class="hljs-literal">None</span>:
n = suivant(n)
<span class="hljs-comment">## on met à jour le noeud suivant</span>
n[<span class="hljs-number">1</span>] = creerNoeud(val,<span class="hljs-literal">None</span>)
<span class="hljs-keyword">return</span> l
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">longueur</span>(<span class="hljs-params">l</span>):</span>
lg = <span class="hljs-number">0</span>
n = l
<span class="hljs-keyword">while</span> n != <span class="hljs-literal">None</span>:
lg += <span class="hljs-number">1</span>
n = suivant(n)
<span class="hljs-keyword">return</span> lg
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">ajouterPlace</span>(<span class="hljs-params">l,val,x</span>):</span>
<span class="hljs-comment">## attention, il faut vérifier que x est cohérent par</span>
<span class="hljs-comment">## rapport à la liste</span>
<span class="hljs-keyword">assert</span>(x>=<span class="hljs-number">0</span>)
<span class="hljs-keyword">assert</span>(x<longueur(l) <span class="hljs-keyword">or</span> (x==<span class="hljs-number">0</span> <span class="hljs-keyword">and</span> longueur(l)==<span class="hljs-number">0</span> ))
<span class="hljs-keyword">if</span> l == <span class="hljs-literal">None</span>:
<span class="hljs-comment">## normalement, suite au assert, x vaut 0</span>
<span class="hljs-keyword">return</span> creerNoeud(val,<span class="hljs-literal">None</span>)
<span class="hljs-keyword">else</span>:
xcourant = x
n = l <span class="hljs-comment">## n pointeur sur la même adresse que l</span>
<span class="hljs-keyword">while</span> xcourant != <span class="hljs-number">0</span>:
setSuivant(n,suivant(n))
xcourant = xcourant - <span class="hljs-number">1</span>
nn = creerNoeud(val,suivant(n)) <span class="hljs-comment">## 1 (creation nn), #2 branchment de nn sur le suivant de n</span>
setSuivant(n,nn) <span class="hljs-comment">## 3</span>
<span class="hljs-keyword">return</span> l <span class="hljs-comment">## l'adresse de l n'a pas bougé</span>
l = creerListeVide()
l = ajouterDebut(l,<span class="hljs-number">28</span>)
l = ajouterDebut(l,<span class="hljs-number">16</span>)
l = ajouterDebut(l,<span class="hljs-number">23</span>)
l = ajouterFin(l,<span class="hljs-number">100</span>)
l = ajouterPlace(l,<span class="hljs-number">67</span>,<span class="hljs-number">2</span>)
print(longueur(l))
print(l[<span class="hljs-number">1</span>][<span class="hljs-number">1</span>][<span class="hljs-number">0</span>])
print(id(l[<span class="hljs-number">1</span>]))
</code></pre></div>
<p>En effet ce que je rechercher c’est à programmer par à l’aide de fonction mais sans passer par le type class. (j’ai trouver pleins d’exemple sur internet mais je souhaiterais faire sans.</p>Les listes doublement chaînée, message #2350862021-06-08T16:39:47+02:00kayou/@kayouhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235086<p>Dans ton 1<sup>er</sup> message tu parles de programmation fonctionnelle tu ne confondrais pas pas avec programmation à l’aide de fonctions ?</p>
<p>Ton code actuellement n’utlise pas vraiment les principes de la <a href="https://fr.wikipedia.org/wiki/Programmation_fonctionnelle">programmation fonctionelle</a>, et si python donne accès a certains element de programmation fonctionnelle, ce n’est pas un language prévu pour cet usage.</p>
<p>Dans le 2eme message avec la liste des fonctions à creer : </p>
<p>La description de ce qui est retouné par CreerNoeudLDC, correspond déja la definition d’un objet.</p>
<blockquote>
<p>• Créer la fonction CreerNoeudLDC(val,precedent,suivant) : NoeudLDC
o val (entier) : la valeur contenue dans le noeud
o precedent (NoeudLDC) : le nœud précédent. Vaut None pour un nœud en début de liste
o suivant (NoeudLDC) : le nœud suivant. Vaut None pour un nœud en fin de liste</p>
</blockquote>
<p>De plsu , la spec de la fonction `EstNoeudLDC' est :</p>
<blockquote>
<p>• Créer la fonction EstNoeudLDC(n : NoeudLDC) : booleen : qui vérifie que n est bien un nœud de liste doublement chainée, c’est-à-dire que n vaut None ou :
o n est une liste de 3 éléments (la fonction native isinstance sera utile)</p>
</blockquote>
<p>La définition de la fonction et l’utlisation de <code>isinstance</code> pour verifier que tu as un bien un noeud en argument laisse à penser que les noeuds sont des objets, je pense que tu devrais creer une classe <code>NoeudLDC</code> avec uniquement 3 proprietés : val, precedent et suivant, cette classe aura uniquement la méthode __init__.</p>
<p>Ensuite tu codes des fonctions "normales" qui travaillent sur des objet <code>NoeudLDC</code></p>
<p>Nota: le code que tu as soumis ne fait rien d’autres que définir des fonctions, as tu essayé de créer une liste chainée ? quels ont les résultats ?</p>Les listes doublement chaînée, message #2350842021-06-08T16:07:45+02:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235084<p>Comment faire quoi plus précisément ? Les fonctions manquantes ?</p>
<p>Je pense que tu pourrais déjà retravailler et simplifier ton code existant :</p>
<ul>
<li>les <code>== True</code> dans les conditions sont inutiles, une expression booléenne s’évalue déjà à <code>True</code> ou <code>False</code></li>
<li>pour comparer un objet avec <code>None</code> on utilisera l’opérateur <code>is</code> (test d’identité) plutôt que <code>==</code> (test d’égalité)</li>
<li>ta fonction <code>creerNoeudLDC</code> peut être grandement simplifiée puisque tout ce qu’elle fait se résumé en <code>return [val, precedent, suivant]</code>. Par contre ne devrait-elle pas s’occuper aussi de créer les liaisons avec les nœuds voisins ?</li>
</ul>Les listes doublement chaînée, message #2350602021-06-07T19:47:21+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235060<p><a href="/membres/voir/entwanne/" rel="nofollow" class="ping ping-link">@<span class="ping-username">entwanne</span></a> je recherche comment faire car je ne trouve aucun exemple sur la toile <img src="/static/smileys/svg/triste.svg" alt=":(" class="smiley"></p>Les listes doublement chaînée, message #2350472021-06-07T10:15:21+02:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235047<figure><blockquote>
<p>J’aimerais savoir si une personne a déjà fait ceci car je trouve uniquement des exemples avec de la POO.</p>
<p>Je souhaiterais comprendre comment faire en ayant un exemple <img src="/static/smileys/svg/clin.svg" alt=";)" class="smiley"></p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p234998">lesnox</a></figcaption></figure>
<p>Oui à titre d’exercice, mais je comprends pas trop quelles sont tes questions.</p>Les listes doublement chaînée, message #2350112021-06-05T19:05:44+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235011<p>Oui il y a une erreur sur un indice que je n’ai pas encore corriger.</p>Les listes doublement chaînée, message #2350042021-06-05T15:17:42+02:00etherpin/@etherpinhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235004<p>Le code que tu présentes marche-t-il ?</p>Les listes doublement chaînée, message #2349982021-06-05T12:04:04+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p234998<p>J’aimerais savoir si une personne a déjà fait ceci car je trouve uniquement des exemples avec de la POO.</p>
<p>Je souhaiterais comprendre comment faire en ayant un exemple <img src="/static/smileys/svg/clin.svg" alt=";)" class="smiley"></p>Les listes doublement chaînée, message #2349972021-06-05T11:58:55+02:00etherpin/@etherpinhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p234997<p>Quels sont le ou les problèmes ?</p>Les listes doublement chaînée, message #2349952021-06-05T10:10:57+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p234995<p>Bonjour à tous, </p>
<p>Dans une première partie je voudrais créer ses fonctions pour les listes doublement chainée : </p>
<div class="hljs-code-div hljs-code-hy"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span></div><pre><code class="hljs language-hy">• Créer la fonction CreerNoeudLDC(<span class="hljs-name">val</span>,precedent,suivant) : NoeudLDC
o val (<span class="hljs-name">entier</span>) : la valeur contenue dans le noeud
o precedent (<span class="hljs-name">NoeudLDC</span>) : le nœud précédent. Vaut <span class="hljs-literal">None</span> pour un nœud en début de liste
o suivant (<span class="hljs-name">NoeudLDC</span>) : le nœud suivant. Vaut <span class="hljs-literal">None</span> pour un nœud en fin de liste
• Créer la fonction EstNoeudLDC(<span class="hljs-name">n</span> : NoeudLDC) : booleen : qui vérifie que n est bien un nœud de liste doublement chainée, c’est-à-dire que n vaut <span class="hljs-literal">None</span> ou :
o n est une liste de <span class="hljs-number">3</span> éléments (<span class="hljs-name">la</span> fonction native isinstance sera utile)
o n[<span class="hljs-number">0</span>] est un entier
o n[<span class="hljs-number">1</span>] et n[<span class="hljs-number">2</span>] sont aussi des NoeudLDC (<span class="hljs-name">fonction</span> récursive)
• Créer les fonctions d’accès aux données, et de modifications de ces données
o GetValLDC(<span class="hljs-name">n</span> : NoeudLDC) : entier
o GetPrecedentLDC(<span class="hljs-name">n</span> : NoeudLDC) : NoeudLDC
o GetSuivantLDC(<span class="hljs-name">n</span> : NoeudLDC) : NoeudLDC
• Créez les fonctions suivantes :
o LongueurLDC(<span class="hljs-name">l</span>) : entier (<span class="hljs-name">renvoie</span> la longueur de la liste)
o InsererDebutLDC(<span class="hljs-name">l</span>,val) : NoeudLDC (<span class="hljs-name">ins</span>ère un nœud au début de la liste)
o InsererFinLDC(<span class="hljs-name">l</span>,val) : NoeudLDC (<span class="hljs-name">ins</span>ère un nœud à la fin de la liste)
o SupprimerDebutLDC(<span class="hljs-name">l</span>) : NoeudLDC (<span class="hljs-name">supprime</span> le premier nœud de la liste)
o SupprimerFinLDC(<span class="hljs-name">l</span>) : NoeudLDC (<span class="hljs-name">supprime</span> le dernier nœud de la liste)
o AccesLDC(<span class="hljs-name">l</span>,p) : NoeudLDC (<span class="hljs-name">renvoie</span> le nœud d’indice p dans la liste. Le premier nœud a pour indice <span class="hljs-number">0</span>)
o InsererPlaceLDC(<span class="hljs-name">l</span>,val,p) : NoeudLDC (<span class="hljs-name">ins</span>ère le nœud contenant val
juste après le nœud d’indice p <span class="hljs-comment">; le premier nœud a pour indice 0)</span>
o SupprimerPlaceLDC(<span class="hljs-name">l</span>,p) : NoeudLDC (<span class="hljs-name">supprime</span> de l le nœud d’indice p <span class="hljs-comment">; le premier nœud a pour indice 0)</span>
o SupprimerValLDC(<span class="hljs-name">l</span>,val) : NoeudLDC (<span class="hljs-name">supprime</span> de l le premier nœud contenant val <span class="hljs-comment">; premier car en effet, rien n’interdit que la liste contienne des doublons)</span>
o LDC2List(<span class="hljs-name">l</span>) : tableau (<span class="hljs-name">renvoie</span> la liste Python (<span class="hljs-name">tableau</span>) contenant les éléments de l <span class="hljs-comment">; renvoie [] si l vaut None)</span>
o List2LDC(<span class="hljs-name">l</span>) : NoeudLDC (<span class="hljs-name">renvoie</span> la liste doublement chainée contenant dans le même ordre les éléments de la liste Python (<span class="hljs-name">tableau</span>) l <span class="hljs-comment">; renvoie None si l vaut [])</span>
</code></pre></div>
<p>Je souhaiterais ensuite faire un jeux de teste pour tout ça dans un if name == " main ".</p>
<p>Dans une seconde partie, je souhaite créer ses fonctions : </p>
<div class="hljs-code-div hljs-code-stata"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span></div><pre><code class="hljs language-stata">• Créer <span class="hljs-keyword">la</span> fonction EstOrdonneeLDC(<span class="hljs-keyword">l</span>) : booleen, <span class="hljs-keyword">qui</span> renvoie True si <span class="hljs-keyword">la</span> liste <span class="hljs-keyword">est</span> croissante (doublons possibles)
• Créer <span class="hljs-keyword">la</span> fonction TriLDC(<span class="hljs-keyword">l</span>) : NoeudLDC <span class="hljs-keyword">qui</span> renvoie <span class="hljs-keyword">la</span> liste doublement chainé<span class="hljs-keyword">e</span> trié<span class="hljs-keyword">e</span> <span class="hljs-keyword">des</span> entiers <span class="hljs-keyword">de</span> <span class="hljs-keyword">la</span> liste doublement chainé<span class="hljs-keyword">e</span> <span class="hljs-keyword">l</span>. <span class="hljs-keyword">On</span> utilisera LDC2List, puis <span class="hljs-keyword">la</span> fonction <span class="hljs-keyword">sort</span> <span class="hljs-keyword">de</span> Python, puis List2LDC
• Créer <span class="hljs-keyword">la</span> fonction InsereOrdreLDC(<span class="hljs-keyword">l</span>,val) <span class="hljs-keyword">qui</span> <span class="hljs-keyword">ins</span>ère val à <span class="hljs-keyword">sa</span> place dans <span class="hljs-keyword">la</span> liste doublement chainé<span class="hljs-keyword">e</span> croissante <span class="hljs-keyword">l</span>, <span class="hljs-keyword">de</span> manière <span class="hljs-keyword">que</span> <span class="hljs-keyword">l</span> reste croissante
</code></pre></div>
<p>et tester avec un jeux de test comme dans la 1er partie.</p>Les listes doublement chaînée, message #2349812021-06-04T17:23:57+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p234981<p>Bonjour à tous, </p>
<p>Je doit implémenter dans python les listes doublement chaînée avec une programmation fonctionnelle.
Voilà ce que j’ai commencé à faire </p>
<div class="hljs-code-div hljs-code-python"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span><span data-count="29"></span><span data-count="30"></span><span data-count="31"></span><span data-count="32"></span><span data-count="33"></span><span data-count="34"></span><span data-count="35"></span><span data-count="36"></span><span data-count="37"></span><span data-count="38"></span><span data-count="39"></span><span data-count="40"></span><span data-count="41"></span><span data-count="42"></span><span data-count="43"></span><span data-count="44"></span><span data-count="45"></span><span data-count="46"></span><span data-count="47"></span><span data-count="48"></span><span data-count="49"></span><span data-count="50"></span><span data-count="51"></span><span data-count="52"></span><span data-count="53"></span><span data-count="54"></span><span data-count="55"></span><span data-count="56"></span><span data-count="57"></span><span data-count="58"></span><span data-count="59"></span><span data-count="60"></span><span data-count="61"></span><span data-count="62"></span><span data-count="63"></span><span data-count="64"></span><span data-count="65"></span><span data-count="66"></span><span data-count="67"></span><span data-count="68"></span><span data-count="69"></span><span data-count="70"></span><span data-count="71"></span><span data-count="72"></span><span data-count="73"></span><span data-count="74"></span><span data-count="75"></span><span data-count="76"></span><span data-count="77"></span><span data-count="78"></span><span data-count="79"></span><span data-count="80"></span><span data-count="81"></span><span data-count="82"></span><span data-count="83"></span><span data-count="84"></span><span data-count="85"></span><span data-count="86"></span><span data-count="87"></span><span data-count="88"></span><span data-count="89"></span><span data-count="90"></span><span data-count="91"></span><span data-count="92"></span><span data-count="93"></span><span data-count="94"></span><span data-count="95"></span><span data-count="96"></span><span data-count="97"></span><span data-count="98"></span><span data-count="99"></span><span data-count="100"></span><span data-count="101"></span><span data-count="102"></span><span data-count="103"></span><span data-count="104"></span><span data-count="105"></span><span data-count="106"></span><span data-count="107"></span><span data-count="108"></span><span data-count="109"></span><span data-count="110"></span></div><pre><code class="hljs language-python"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">estVide</span>(<span class="hljs-params">l</span>):</span>
<span class="hljs-keyword">if</span>
<span class="hljs-keyword">return</span> premier == <span class="hljs-literal">None</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">creerNoeudLDC</span>(<span class="hljs-params">val, precedent, suivant</span>):</span>
<span class="hljs-string">""" un noeud est une liste Python de trois cases [valeur,noeud présecéent, noeud suivant]
"""</span>
<span class="hljs-keyword">if</span> precedent == <span class="hljs-literal">None</span>:
<span class="hljs-keyword">return</span> [val, <span class="hljs-literal">None</span>, <span class="hljs-literal">None</span>]
<span class="hljs-keyword">if</span> suivant == <span class="hljs-literal">None</span>:
<span class="hljs-keyword">return</span> [val, precedent, <span class="hljs-literal">None</span>]
<span class="hljs-keyword">else</span>:
<span class="hljs-keyword">return</span> [val, precedent, suivant]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">EstNoeudLDC</span>(<span class="hljs-params">n</span>):</span>
<span class="hljs-keyword">if</span> n == <span class="hljs-literal">None</span>:
<span class="hljs-keyword">return</span> <span class="hljs-literal">True</span>
<span class="hljs-keyword">if</span> (isinstance(n[<span class="hljs-number">0</span>], int) == <span class="hljs-literal">True</span> <span class="hljs-keyword">and</span> isinstance(EstNoeudLDC(n[<span class="hljs-number">1</span>]), <span class="hljs-literal">True</span>) == <span class="hljs-literal">True</span> <span class="hljs-keyword">and</span> isinstance(EstNoeudLDC(n[<span class="hljs-number">2</span>]), <span class="hljs-literal">True</span>) == <span class="hljs-literal">True</span>):
<span class="hljs-keyword">return</span> <span class="hljs-literal">True</span>
<span class="hljs-keyword">else</span> :
<span class="hljs-keyword">return</span> <span class="hljs-literal">False</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">GetValLDC</span>(<span class="hljs-params">n</span>):</span>
<span class="hljs-keyword">assert</span>(n != <span class="hljs-literal">None</span>) <span class="hljs-comment">## on ne peut pas obtenir la valeur d'une liste vide</span>
<span class="hljs-keyword">return</span> n[<span class="hljs-number">0</span>]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">GetSuivantLDC</span>(<span class="hljs-params">n</span>):</span>
<span class="hljs-string">"""
"""</span>
<span class="hljs-keyword">assert</span>(n != <span class="hljs-literal">None</span>) <span class="hljs-comment">## on ne peut pas obtenir la noeud suivant sur une liste vide</span>
<span class="hljs-keyword">return</span> n[<span class="hljs-number">1</span>]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">GetPrecedentLDC</span>(<span class="hljs-params">n</span>):</span>
<span class="hljs-string">"""
"""</span>
<span class="hljs-keyword">assert</span>(n != <span class="hljs-literal">None</span>) <span class="hljs-comment">## on ne peut pas obtenir la noeud précédent sur une liste vide</span>
<span class="hljs-keyword">return</span> n[<span class="hljs-number">2</span>]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">LongueurLDC</span>(<span class="hljs-params">l</span>):</span>
lg = <span class="hljs-number">0</span>
n = GetValLDC(<span class="hljs-number">0</span>)
<span class="hljs-keyword">while</span> n != <span class="hljs-literal">None</span>:
lg += <span class="hljs-number">1</span>
n = GetSuivantLDC(l)
<span class="hljs-keyword">return</span> lg
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">InsererDebutLDC</span>(<span class="hljs-params">l,val</span>):</span>
<span class="hljs-keyword">if</span> l == <span class="hljs-literal">None</span>:
<span class="hljs-keyword">return</span> creerNoeudLDC(val, <span class="hljs-literal">None</span>, <span class="hljs-literal">None</span>)
<span class="hljs-keyword">else</span>:
l[<span class="hljs-number">0</span>] = creerNoeudLDC(val, GetSuivantLDC(l[<span class="hljs-number">0</span>]), <span class="hljs-literal">None</span>)
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">InsererFinLDC</span>(<span class="hljs-params">l,val</span>):</span>
<span class="hljs-keyword">if</span> l == <span class="hljs-literal">None</span>:
<span class="hljs-keyword">return</span> creerNoeud(val, <span class="hljs-literal">None</span>, <span class="hljs-literal">None</span>)
<span class="hljs-keyword">else</span>:
<span class="hljs-comment">## on parcoure la liste jusqu'à atteindre le dernier noeud</span>
n = l
<span class="hljs-keyword">while</span> GetSuivantLDC(n) != <span class="hljs-literal">None</span>:
n = GetSuivantLDC(n)
<span class="hljs-comment">## on met à jour le noeud suivant</span>
GetPrecedentLDC(n)[<span class="hljs-number">1</span>] = creerNoeud(val, <span class="hljs-literal">None</span>, GetPrecedentLDC(n))
n[<span class="hljs-number">1</span>] = creerNoeud(val, <span class="hljs-literal">None</span>, <span class="hljs-literal">None</span>)
<span class="hljs-keyword">return</span> l
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">SupprimerDebutLDC</span>(<span class="hljs-params">l</span>):</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">SupprimerFinLDC</span>(<span class="hljs-params">l</span>):</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">AccesLDC</span>(<span class="hljs-params">l,p</span>):</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">InsererPlaceLDC</span>(<span class="hljs-params">l,val,p</span>):</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">SupprimerPlaceLDC</span>(<span class="hljs-params">l,p</span>):</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">SupprimerValLDC</span>(<span class="hljs-params">l,val</span>):</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">LDC2List</span>(<span class="hljs-params">l</span>):</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">List2LDC</span>(<span class="hljs-params">l</span>):</span>
<span class="hljs-comment">##if __name__ == '__main__':</span>
<span class="hljs-comment">## print('Test liste vide :', test_creation_liste())</span>
<span class="hljs-comment">## print('Test lng vide :', test_longueur_liste_vide())</span>
<span class="hljs-comment">## print('Test ajout tête :', test_ajout_tete())</span>
<span class="hljs-comment">## print('Test ajout tête :', test_ajout_tete2())</span>
<span class="hljs-comment">## print('Test tableau :', test_depuis_tableau())</span>
<span class="hljs-comment">#### Part 2 #####</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">EstOrdonneeLDC</span>(<span class="hljs-params">l</span>):</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">TriLDC</span>(<span class="hljs-params">l</span>):</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">InsereOrdreLDC</span>(<span class="hljs-params">l,val</span>):</span>
</code></pre></div>
<p>Je suis preneur si vous avez des ressources sur le sujet car j’ai trouver beaucoup de Programmation orienté objet mais pas de programmation fonctionnelle ? </p>
<p>Merci d’avances.
Lesnox</p>Test d'égalité de listes chainées en C / récursif , message #1652682017-10-28T21:47:37+02:00Drakop/@Drakophttps://zestedesavoir.com/forums/sujet/9584/test-degalite-de-listes-chainees-en-c-recursif/?page=1#p165268<p>Merci beaucoup ! </p>Test d'égalité de listes chainées en C / récursif , message #1652202017-10-28T14:26:35+02:00elegance/@elegancehttps://zestedesavoir.com/forums/sujet/9584/test-degalite-de-listes-chainees-en-c-recursif/?page=1#p165220<p>Dans ton premier code , tu avais une instruction :</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1</pre></div></td><td class="code"><div class="codehilite"><pre><span></span>egal(l1->suivant,l2->suivant);
</pre></div>
</td></tr></table></div>
<p>en ligne 8.</p>
<p>tu dis : dis moi si les éléments l1->suivant et l2-> suivant sont identiques, mais de toutes façons, je n’écouterai pas la réponse. (pas d’écouteur pour recevoir la réponse de la fonction)</p>
<p>Quand tu appelles une fonction, en principe, c’est parce que tu es intéressé par le code retour de cette fonction, et donc, ça passe par :</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1</pre></div></td><td class="code"><div class="codehilite"><pre><span></span>i = fonct()
</pre></div>
</td></tr></table></div>
<p>ou bien :</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1</pre></div></td><td class="code"><div class="codehilite"><pre><span></span>if fonct() then ...
</pre></div>
</td></tr></table></div>
<p>ou encore </p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1</pre></div></td><td class="code"><div class="codehilite"><pre><span></span>return fonct()
</pre></div>
</td></tr></table></div>Test d'égalité de listes chainées en C / récursif , message #1652092017-10-28T12:13:42+02:00satenske/@satenskehttps://zestedesavoir.com/forums/sujet/9584/test-degalite-de-listes-chainees-en-c-recursif/?page=1#p165209<p>En gros, si une fonction à un type de retour, c’est que ton type de retour doit servir. Soit tu récupères la valeur pour un traitement, soit tu retourne la valeur. Et ce, indépendamment du fait que ta fonction soit récursive ou non.</p>
<p>Ajouté à ça, que si ta fonction doit retourner quelque chose, il faut que dans tous les cas tu retourne une valeur; dans ton cas, ta méthode ne comportait pas de return si tous les if étaient évalués à false.</p>
<p>Mais typiquement si tu as une fonction récursive qui ne retourne rien, <code>void</code>, évidemment aucun return à faire.</p>Test d'égalité de listes chainées en C / récursif , message #1652072017-10-28T11:34:15+02:00ache/@achehttps://zestedesavoir.com/forums/sujet/9584/test-degalite-de-listes-chainees-en-c-recursif/?page=1#p165207<p>En général, non mais si tu veux faire une fonction qui retourne quelque chose de manière recursif alors oui, c’est obligatoire ^^"</p>
<p>Le principe n’est pas de savoir si c’est obligatoire ou pas.</p>
<p>Le principe c’est de comprendre <strong>pourquoi tu dois le faire</strong> !</p>Test d'égalité de listes chainées en C / récursif , message #1652062017-10-28T11:30:28+02:00Drakop/@Drakophttps://zestedesavoir.com/forums/sujet/9584/test-degalite-de-listes-chainees-en-c-recursif/?page=1#p165206<p>D’accord merci beaucoup et pour le récursivité en général c’est obligatoire le return devant l’appel de la fonction ? </p>