Was ergibt sich der Unterschied in diesen beiden Segmenten des Codes

Question

Ich lerne Datenstruktur und merge Linklist Übung in Python zu tun. Aber ich begegne einigen verwirrenden Problemen. Die Definition des Knotens ist:

class ListNode: 
    def __init__(self, x): 
     self.val = x 
     self.next = None 

in folgenden Funktionen, Parameter l1 und l2 sind Linklisten zusammengeführt werden, und die Funktion sollte eine fusionierte Linkliste zurück.

Die erste Implementierung ist wie folgt:

def merge(l1, l2): 
    if l1 == None: 
     return l2 
    if l2 == None: 
     return l1 
    p = l1 
    q = l2 
    if l1.val < l2.val: 
     l = l1 
    else: 
     l = l2 
    start = l 
    while p and q: 
     if p.val < q.val: 
      l.next = p 
      p = p.next 
     else: 
      l.next = q 
      q = q.next 
     l = l.next 
    if p!= None: 
     l.next = p 
    if q!=None: 
     l.next = q 
    return start 

jedoch nicht, weil arbeiten, wenn es um die Schleife eintritt, da l1 eine unendliche linkelist das wird Werte all 0. Die nächste Implementierung nicht die Ursache für dieses Problem :

def mergeTwoLists(self, l1, l2): 
    if l1 == None: 
     return l2 
    if l2 == None: 
     return l1 
    l = ListNode(0) 
    start = l 
    while l1 and l2: 
     if l1.val < l2.val: 
      l.next = l1 
      l1 = l1.next 
     else: 
      l.next = l2 
      l2 = l2.next 
     l = l.next 
    if l1!= None: 
     l.next = l1 
    if l2!=None: 
     l.next = l2 
    return start.next 

Was ergibt den Unterschied zwischen diesen zwei Segmenten? Warum wird l1 zu einer unendlichen Linkliste? Und ich habe noch eine weitere Frage: Variable 'l' wurde am Anfang 'Start' zugewiesen, in jeder Schleife bewegt sich l zum nächsten Knoten, während Start keine Änderung hat. Warum zeigt Start am Ende auf eine zusammengeführte Liste? Warum nicht gleich bleiben oder nur gleich zu l?

Ich hoffe, jemand kann meine Frage beantworten. Vielen Dank.

Answer 1

Angenommen l1.val < l2.val, also l = l1. Seit p = l1 und q = l2 dann p.val < q.val, also dann l.next = p. Das heißt l.next ist l1, was l ist. Der Knoten zeigt auf sich selbst. Indem Sie mit einem neuen Knoten l = ListNode(0) in der zweiten Implementierung beginnen, vermeiden Sie diese Selbstreferenz.