Je sais comment créer le lien J'ai déjà lu la réponse à Cette question . Cependant, je ne comprends pas comment si la tête est Si quelqu'un pouvait me montrer le merci pour toute aide
Edit: Je n'ai besoin que de la liste à parcourir. Si tel est le cas, la logique doit-elle être modifiée de manière drastique? lien et linearlinkedlist classes, mais je ne peux tout simplement pas pour la vie de moi de comprendre comment les modifier dans une création de CircularLinkedList .
Aucun , alors comment un objet Aucun -TYPE a un suivant attribut? Je n'arrive tout simplement pas de saisir le concept.
__ init __ fonction d'un échantillon circulaireLinkedlist et une simple explication sur la façon dont cela fonctionne, je pense que je pourrais la comprendre. < / p>
5 Réponses :
L'étape cruciale ici est que la tête n'est pas Aucun code>. Seules les données du nœud code> lien code> de la tête sont Aucun code>, et il pointe de lui-même via son attribut suivant code>. Comme mentionné dans la réponse que vous avez liée, cela ressemblerait à ceci: def __init__(self):
self.head = Link(None, None)
self.head.next = self.head
Je pense que je commence à l'obtenir. Merci!
en effet; S'il n'y a pas de nœuds, il ne peut y avoir de nœuds suivants / précédents: S'il y a un nœud, il se lie à l'envers et en avant à lui-même: P> root
|
v
+-> Node +-> Node <--+
| next---+ next--+ |
+-|---prev <-----prev | |
| +--------------------+ |
+------------------------+
Votre situation pour «No Bonne-nœuds» n'est pas tout à fait la situation que l'OP décrit (bien que ce soit une approche possible). Au lieu de cela, c'est plus étroitement ressemblant à la situation que vous décrivez comme un nœud «un». Votre approche pourrait être une représentation plus pratique, car elle permet de faciliter le Aucun -Test.
Merci pour la représentation visuelle. J'apprécie l'aide!
souvent dans une liste liée circulaire, vous avez un lien spécial qui ne contient pas de données significatives. Au lieu de cela, c'est un "Sentinel" vous permettant de savoir où se trouve le début (et la fin) de la liste. Ce lien existe même lorsque la liste est vide, vos algorithmes vont donc fonctionner sur toutes les listes, sans beaucoup de cas spéciaux nécessitant un code spécial.
class Link:
def __init__(self, data, next):
self.data = data
self.next = next
class CircularLinkedList:
def __init__(self):
self.head = Link(None, None) # this is the sentinel node!
self.head.next = self.head # link it to itself
def add(self, data): # no special case code needed for an empty list
self.head.next = Link(data, self.head.next)
def __contains__(self, data): # example algorithm, implements the "in" operator
current = self.head.next
while current != self.head:
if current.data == data: # element found
return True
current = current.next
return False
Supposons que je supprime le dernier lien. Ajustera-t-il automatiquement à la boucle au premier lien ou devrai-je me rendre compte manuellement dans ma fonction Supprimer? * Le figuré en jouant avec elle. Merci pour l'aide!
#Linked List Program to Add and Delete Node Form Head, Tail, in Between Nodes.
class Node:
""" Node Class having the data and pointer to the next Node"""
def __init__(self,value):
self.value=value
self.nextnode=None
class CircularLinkedList(object):
""" Linked List Class to point the value and the next nond"""
def __init__(self):
self.head=None
def add_head_node(self,value):
node=Node(value)
if self.head is None:
self.head=node
self.head.nextnode=self.head
crnt_node=node
crnt_node.nextnode=self.head
first_node=self.head
while first_node.nextnode is not self.head:
first_node=first_node.nextnode
first_node.nextnode=crnt_node
self.head=crnt_node
#Adding elements in linked list to the tail.
def add_tail_node(self,value):
node=Node(value)
if self.head is None:
self.head=node
self.head.nextnode=self.head
crnt_node=node
last_node=self.head
while last_node.nextnode is not self.head:
last_node=last_node.nextnode
#pointing head's last element to given node
last_node.nextnode=crnt_node
#pointing last node next to head nodes of element
crnt_node.nextnode=self.head
#Adding elements in linked after given Node.
def add_after_node(self,after_value,value):
node=Node(value)
if self.head is None:
self.head=node
self.head.nextnode=self.head
new_node=node
after_node=Node(after_value)
head_node=self.head
while head_node.value !=after_node.value:
head_node=head_node.nextnode
last_node=head_node.nextnode
head_node.nextnode=new_node
new_node.nextnode=last_node
head_node=head_node.nextnode
#Adding elements in linked before given Node.
def add_before_node(self,bfr_value,value):
node=Node(value)
if self.head is None:
self.head=node
self.head.nextnode=self.head
new_node=node
bfr_node=Node(bfr_value)
head_node=self.head
while head_node.nextnode.value!=bfr_node.value:
head_node=head_node.nextnode
last_node=head_node.nextnode
head_node.nextnode=new_node
new_node.nextnode=last_node
head_node=head_node.nextnode
#self.head=head_node.nextnode
#deleting Head Node of Linked List
def del_head_node(self):
if self.head is None:
print('Can not delete elements from Empty Linked List')
return
crnt_node=self.head.nextnode
pointer_head=self.head.nextnode
while pointer_head.nextnode.value!=self.head.value:
pointer_head=pointer_head.nextnode
pointer_head.nextnode=crnt_node
self.head=crnt_node
#deleting tail Node of Linked List
def del_tail_node(self):
if self.head is None:
print('Can not delete elements from Empty Linked List')
return
crnt_node=self.head.nextnode
#head_node=self.head
while crnt_node.nextnode.nextnode.value!=self.head.value:
crnt_node=crnt_node.nextnode
crnt_node.nextnode=self.head
#delete beteween node from Linked List
def del_bw_node(self,value):
node=Node(value)
if self.head is None:
print('Can not delete elements from Empty Linked List')
return
crnt_node=self.head
while crnt_node.nextnode.value!=node.value:
crnt_node=crnt_node.nextnode
last_node=crnt_node.nextnode.nextnode
crnt_node.nextnode=last_node
#Function to print linked list node
def print_list(self):
crnt_node=self.head
while True:
print(f'{crnt_node.value}->',end='')
if crnt_node.nextnode is self.head:
print(f'{self.head.value}',end='')
break
crnt_node = crnt_node.nextnode
print()
cir_llist=CircularLinkedList()
cir_llist.add_head_node(1)
cir_llist.print_list()
cir_llist.add_head_node(2)
cir_llist.print_list()
cir_llist.add_head_node(3)
cir_llist.print_list()
cir_llist.add_head_node(4)
cir_llist.print_list()
cir_llist.add_head_node(5)
cir_llist.print_list()
cir_llist.add_tail_node(6)
cir_llist.print_list()
cir_llist.add_tail_node(8)
cir_llist.print_list()
cir_llist.add_after_node(6,7)
cir_llist.print_list()
cir_llist.add_before_node(6,0)
cir_llist.print_list()
cir_llist.add_before_node(0,10)
cir_llist.print_list()
cir_llist.del_head_node()
cir_llist.print_list()
cir_llist.del_head_node()
cir_llist.print_list()
cir_llist.del_tail_node()
cir_llist.print_list()
cir_llist.del_tail_node()
cir_llist.print_list()
cir_llist.del_bw_node(10)
cir_llist.print_list()
cir_llist.del_bw_node(0)
cir_llist.print_list()
for i in range(8):
my_node = my_node.next_node
print(my_node,end='->')
Pouvez-vous dessiner un diagramme pour une telle liste avec zéro, un, deux éléments etc? Cela devrait vous aider à déterminer comment organiser des choses. Aussi, demandez-vous si la liste est censée seulement contenir des liens dans une direction ou l'autre.
J'ai seulement besoin d'eux pour être connectés seuls. Cela crée-t-il une différence massive si j'en ai besoin de traverser également à l'envers?
Pour le dessin, c'est facile, mais certaines opérations sur une liste individuellement liée sont plus compliquées que sur une liste doublement liée.