"Un livre pour former les compétences de programmation pour combattre dans le monde" Exemple de réponse de code Python --2.5 Somme de deux nombres affichés dans la liste
python
from chap2_function import*
def dll_from_node(node):
dll = DoublyLinkedList()
while(node is not None):
dll.append(node.data)
last = node
node = node.next
return dll
def addLists(l1,l2,carry):
if l1==None and l2==None and carry==0:
return None
value = carry
if l1:
value = value + l1.data
if l2:
value = value + l2.data
result=Node(value%10)
if l1 or l2:
more = addLists(None if l1==None else l1.next,
None if l2==None else l2.next,
1 if value >= 10 else 0
)
result.next = more
return result
dll_1 = DoublyLinkedList()
# DLL: None -> 7(tête) -> 1 -> 6(dernier) -> None
dll_1.append(7)
dll_1.append(1)
dll_1.append(6)
dll_1.printList(dll_1.head)
dll_2 = DoublyLinkedList()
# DLL: None -> 7(tête) -> 1 -> 6(dernier) -> None
dll_2.append(5)
dll_2.append(9)
dll_2.append(2)
dll_2.printList(dll_2.head)
result_1 = addLists(dll_1.head,dll_2.head,0)
dll_result_1 = dll_from_node(result_1)
dll_result_1.printList(dll_result_1.head)
dll_3 = DoublyLinkedList()
# DLL: None -> 9(tête) -> 9 -> 9(dernier) -> None
dll_3.append(9)
dll_3.append(9)
dll_3.append(9)
dll_3.printList(dll_3.head)
dll_4 = DoublyLinkedList()
# DLL: None -> 9(tête) -> 9 -> 9(dernier) -> None
dll_4.append(9)
dll_4.append(9)
dll_4.append(9)
dll_4.printList(dll_4.head)
result_2 = addLists(dll_3.head,dll_4.head,0)
dll_result_2 = dll_from_node(result_2)
dll_result_2.printList(dll_result_2.head)
chap2_function.py
#Classe de nœud
class Node:
#constructeur
def __init__(self, data):
self.data = data
self.next = None
self.prev = None
#Classe de liste bidirectionnelle
class DoublyLinkedList:
#constructeur
def __init__(self):
self.head = None
#Insérer un nœud à partir du premier nœud
def push(self, new_data):
#Génération de nœuds
new_node = Node(new_data)
#Faites du nœud suivant du nouveau nœud le nœud principal en premier lieu
new_node.next = self.head
#Bien qu'il s'agisse d'un nœud principal au départ, le nœud précédent est remplacé par un nouveau nœud
if self.head is not None:
self.head.prev = new_node
#Faire du nouveau nœud un nœud principal
self.head = new_node
#Insérer un nœud à un point intermédiaire
def insert(self, prev_node, new_data):
# prev_Spécifiez s'il faut insérer un nœud après le nœud spécifié par nœud
#Si aucun, quitte la fonction
if prev_node is None:
print("the given previous node cannot be NULL")
return
#Génération de nœuds
new_node = Node(new_data)
#Précédente le nœud suivant du nouveau nœud_Faites-en le nœud suivant du nœud spécifié par nœud
new_node.next = prev_node.next
# prev_Fait du nœud suivant du nœud spécifié par nœud un nouveau nœud
prev_node.next = new_node
#Précédent le nœud précédent du nouveau nœud_Faites-en le nœud spécifié par le nœud
new_node.prev = prev_node
#Précédente le nœud suivant du nouveau nœud_J'en ai fait le nœud suivant du nœud spécifié dans node, mais le nœud précédent de ce nœud est également transformé en nouveau nœud
if new_node.next is not None:
new_node.next.prev = new_node
#Insérer le nœud du dernier nœud
def append(self, new_data):
#Génération de nœuds
new_node = Node(new_data)
#Aucune définition du nœud suivant du nouveau nœud
new_node.next = None
#Si aucun nœud principal n'est défini (liste vide), définissez un nouveau nœud comme nœud principal
if self.head is None:
new_node.prev = None
self.head = new_node
return
#Définir le nœud final (scan avant)
last = self.head
while(last.next is not None):
last = last.next
#Désignez un nouveau nœud comme dernier nœud
last.next = new_node
# 7.Faire du nœud précédent du nouveau nœud le dernier nœud en premier lieu
new_node.prev = last
return
def delete(self,del_node):
if self.head == None or del_node == None:
return
if self.head == del_node:
self.head = del_node.next
if del_node.next != None:
del_node.next.prev = del_node.prev
if del_node.prev != None:
del_node.prev.next = del_node.next
def printList(self, node):
print("Liste bidirectionnelle: \n")
print("Balayage avant")
while(node is not None):
print(node.data,end="")
last = node
node = node.next
if node:
print(" -> ",end="")
else:
print("\n")
print("Balayage inversé")
while(last is not None):
print(last.data,end="")
last = last.prev
if last:
print(" -> ",end="")
else:
print("\n")
if __name__ == '__main__':
#Générer une liste bidirectionnelle vide
# DLL: None
dll = DoublyLinkedList()
# DLL: None -> 6(tête/dernier) -> None
dll.append(6)
# DLL: None -> 7(tête) -> 6(dernier) -> None
dll.push(7)
# DLL: None -> 1(tête) -> 7 -> 6(dernier) -> None
dll.push(1)
# DLL: None -> 1(tête) -> 7 -> 6 -> 4(dernier) -> None
dll.append(4)
# DLL: None -> 1(tête) -> 7 -> 8 -> 6 -> 4(dernier) -> None
dll.insert(dll.head.next, 8)
# DLL: None -> 1(tête) -> 8 -> 6 -> 4(dernier) -> None
dll.delete(dll.head.next)
dll.printList(dll.head)
[1] GeeksforGeeks: Doubly Linked List | Set 1 (Introduction and Insertion) [2] GeeksforGeeks: Delete a node in a Doubly Linked List
Recommended Posts