Erreur lors de la fusion des listes liées triées à une liste liée triée de Python

Excusez-moi, je n'ai aucune réputation de commentaire, alors j'écris est une réponse. Je pense que Sunitha signifiait que vous devez utiliser .Cur_node code> pas dans la fonction fusion_lists code> Définition mais dans l'appel de la fonction. Dans ce cas, les arguments de la fonction seront de type nœud code>, pas linkedlist code> et mentionné dans votre erreur de questions seront éliminés. Mais aussi dans ce cas, vous obtiendrez une erreur car la fonction merge_lists code> retournera un nœud, pas une liste et, par exemple, l'appel du list_print () code> ne sera pas être applicable à la valeur renvoyée. Vous pouvez surmonter cette erreur avec le code suivant:

class List1(object):
    def __init__(self, a = 0):
        self.data = a
        self.next = None

    def add_node(self, prev, a):
        q = List1(a)
        q.next = prev.next
        prev.next = q

    def list_print(self):
        q=self.next
        while q != None:
            print(q.data)
            q=q.next
# end of class

def merge_lists2(h1, h2):
    node1 = h1.next
    node2 = h2.next
    list = List1()
    q = list.next
    while node1 or node2:
        if node1 and node2 and node1.data > node2.data:
            if q:
                list.add_node(q, node1.data)  # Add a node to the end of a list
                q = q.next                    # End of a list moves to tne new position
            else:
                list.add_node(list, node1.data)  # Add a node to the beginning of a list (after the leading node)
                q = list.next                    # New end position
            node1 = node1.next
        elif node1 and node2 and node1.data <= node2.data:
            if q:
                list.add_node(q, node2.data)
                q = q.next
            else:
                list.add_node(list, node2.data)
                q = list.next
            node2 = node2.next
        if node1 == None and node2:  # If the 1st list finished first
            while node2:
                if q:
                    list.add_node(q, node2.data)
                    q = q.next
                node2 = node2.next
        if node2 == None and node1:  # If the 2nd list finished first
            while node1:
                if q:
                    list.add_node(q, node1.data)
                    q = q.next
                node1 = node1.next
    return list

l1 = List1()
l1.add_node(l1,1)
l1.add_node(l1,5)
l1.add_node(l1,7)

l1.list_print()
print()

l2 = List1()
l2.add_node(l2,2)
l2.add_node(l2,6)
l2.add_node(l2,8)
l2.add_node(l2,15)  # Extra nodes for testing purpose
l2.add_node(l2,20)

l2.list_print()
print()

l3 = List1()
l3 = merge_lists2(l1, l2)
print()
l3.list_print()

J'ai revu cette tâche à nouveau et j'ai obtenu la fonction récursive suivante. XXX

En effet, il est environ trois fois plus court que non récursif et vraiment plus élégant. Lors de l'exécution, cela modifie la liste spécifiée par le premier argument. La classe est extraite de mon exemple précédent. La fonction est testée pour les cas lorsque la première liste est plus longue que la seconde, lorsqu'elle est plus courte, lorsque l'un de son nœud est plus grand que n'importe quel nœud de la deuxième liste et inversement.

upd - des listes de fusion récursives triées dans l'ordre croissant: xxx