2016-05-30 22 views
0

Dies ist ein Code zum Zusammenführen von zwei sortierten verknüpften Listen. Jetzt liegt meine Frage in der Merge-Funktion. Warum verweisen wir new_node1 auf new_node? Was ist falsch daran, new_node1 direkt in der Funktion zu verwenden, statt "Node new_node = new_node1;" (Anyways habe ich versucht, direkt zu verwenden, aber es erzeugt nicht die erforderliche Ausgabe. Es erzeugt nur das letzte Element der zusammengeführten Liste) Verwendet new_node Objekt Standardkonstruktor? Aufwendige Erklärung wird sehr hilfreich sein. Vielen Dank im Voraus.ein Objekt an ein anderes Objekt initialisieren

static class Node{ 
    int data; 
    Node next; 
    Node(int num){ 
     data=num; 
     next=null; 
    } 
} 

// Function for merging two sorted linked list 

public void merge(Linkedlist list1,Linkedlist list2){  
    Linkedlist l=new Linkedlist(); 

    Node new_node1=new Node(0); 
    Node new_node=new_node1; //This line of code is my doubt! 
    while(list1.head!=null || list2.head!=null){  
     if(list1.head!=null && list2.head!=null){ 
     if(list1.head.data<=list2.head.data){ 
      new_node.next=list1.head; // what difference it makes by using new_node.next instead of new_node1 
      list1.head=list1.head.next;   

     } 
     else{ 
      new_node.next=list2.head; 
      list2.head=list2.head.next; 
      }   
     } 
     else if(list1.head==null){   
       new_node.next=list2.head; 
       list2.head=list2.head.next; 
      } 
     else if(list2.head==null){   
       new_node.next=list1.head; 
       list1.head=list1.head.next;     
     } 
     new_node=new_node.next; 
     //new_node1=new_node1.next; 
    } 
    l.printlist(new_node1); 

} 

Antwort

0

Der einzige Unterschied ist in der letzten Zeile, l.printlist(new_node1);. Wenn Sie new_node1 den ganzen Weg durch die Schleife verwenden, dann drucken Sie den letzten Knoten. Wenn Sie new_node den ganzen Weg durch die Schleife verwenden, bleibt new_node1 unverändert und zeigt auf den Kopf der Liste.

Ich empfehle Umbenennung new_node1 zu head_node und new_node zu current_node. Das wird es leichter verständlich machen. Dann sind Sie so etwas wie dieses:

Node head_node = new Node(0); 
Node current_node = head_node; 

// .. build the entire list of nodes .. 

l.printlist(head_node); 
+0

Dank. Ich habe es –

+0

Und können Sie bitte sagen, welchen Konstruktor der Current_node verwenden wird? Ist es der Standardkonstruktor oder der Konstruktor, der mich definiert? –

+0

Es wurde kein neues Objekt erstellt. Kein Konstruktor wird aufgerufen. Beide Variablen zeigen auf das gleiche Objekt, das nur einmal aufgebaut ist, in der Zeile 'Knoten head_node = new Node (0);'. 'current_node' zeigt nur auf das gleiche Objekt, auf das' head_node' zeigt. –

-1

Hier

new_node1 

ist ein Objekt.

Während

new_node 

ist ein Referenz-Variable, die mit den Knoten in der Liste Punkt verwendet wird

+0

Sie denken vielleicht eher an C als an Java. –

+0

Falls nicht klar ist: Weder 'new_node1' noch' new_node' sind Objekte an sich. Sie sind beide Referenzen auf Objekte. Anfangs sind sie Referenzen auf dasselbe Objekt; Am Ende jeder Iteration durch die Schleife wird "neuer_knoten" zu einer Referenz auf ein neues Objekt, während "neuer_knoten1" die ursprüngliche Referenz bleibt. –

+1

Okay! Vielen Dank –

Verwandte Themen