Diese Notiz wurde für eine ganze Woche aussortiert. Ich hoffe, einige Informationen über den schriftlichen Test und das Interview zu haben.
Dieser Artikel enthält den folgenden Inhalt der verlinkten Liste:
1. Erstellung und Durchqueren von einzelnen verknüpften Listen
2. Ermitteln Sie die Anzahl der Knoten in einer einzigen verknüpften Liste
3. Finden Sie den K-lastigen Knoten in einer einzigen verknüpften Liste (Schwertpunkt für Angebot, Frage 15)
4. Ermitteln Sie die Zwischenknoten in einer einzigen verknüpften Liste
5. Zusammenführen zwei bestellte einzelne verknüpfte Listen, und die kombinierten verknüpften Listen sind noch in Ordnung [hohe Häufigkeit des Auftretens] (Schritt nach dem Angebot, Frage 17)
6. Die Umkehrung der einköpfigen Liste [die höchste Häufigkeit des Auftretens] (Schritt nach dem Angebot, Frage 16)
7. Drucken Sie eine einzige verknüpfte Liste vom Ende zum Anfang (Schwert zu bieten, Frage 5)
8. Bestimmen Sie, ob eine einzige verknüpfte Liste einen Ring hat
9. Nehmen Sie die Länge des Rings in der verknüpften Liste heraus
10. Nehmen Sie in der einzelnen verknüpften Liste den Ausgangspunkt des Rings (Schwert für das Angebot, Frage 56) heraus. Diese Frage muss die oben genannten Fragen 8 und 9 verwenden.
11. Bestimmen Sie den ersten Schnittpunkt des Schnittpunkts zwischen zwei einköpfigen Listen (Schwert, die anbieten, Frage 37)
1. Erstellung und Durchqueren von einzelnen verknüpften Listen:
Public Class LinkList {Public Node Head; Wenn der Kopfknoten leer ist, bedeutet dies, dass die verknüpfte Liste noch nicht erstellt wurde. Knoten und platzieren Sie es im aktuellen Knoten hinter (korrelieren Sie den neuen Knoten mit der verknüpften Liste) /Nach Abschluss dieser Operation zeigt der Knoten auf den neu hinzugefügten Knoten}} // Methode: Überqueren Sie die verknüpfte Liste (drucken Sie die verknüpfte Liste aus. Node Node) {if (node == null) {return; {// Anmerkung: Die Berechtigungen der beiden Mitgliedsvariablen können hier nicht zugänglich sein, da die privaten Berechtigungen nur für diese Klasse zugänglich sind. Data = Daten; );Im obigen Code verwendet der Knotenknoten hier eine interne Klasse, um sie darzustellen (Zeilen 33). Der größte Vorteil der Verwendung von Innenklassen besteht darin, dass sie mit äußeren Klassen auf einander zugreifen können.
Hinweis: Die Eigenschaften des internen Klassenzugriffs sind: Interne Klassen können direkt auf Mitglieder von externen Klassen zugreifen, einschließlich privater Klassen.
Um die Zugabe und den Durchgang zu erleichtern, fügen Sie der LinkList -Klasse einen Member -Variablenstrom hinzu, um den Index des aktuellen Knotens darzustellen (Zeile 03).
In der Methode zum Durchqueren der verknüpften Liste (Zeile 20) bedeutet der Parameterknoten, dass er vom Knotenknoten startet und nicht unbedingt vom Kopfknoten aus durchqueren muss.
2. Ermitteln Sie die Anzahl der Knoten in einer einzigen verknüpften Liste:
Achten Sie darauf, ob die verknüpfte Liste leer ist. Die zeitliche Komplexität ist o (n). Dies ist relativ einfach.
Kerncode:
// Methode: Holen Sie sich die Länge der einzelnen verknüpften Liste öffentliche Int GetLength (Knotenkopf) {if (head == null) {return 0; Länge th ++;3. Finden Sie den k-lastigen Knoten in einer einzigen verknüpften Liste:
3.1 Gewöhnliche Ideen:
Iterieren Sie zunächst die gesamte verknüpfte Liste von Anfang bis Ende, berechnen Sie die Länge der verlinkten Liste und erhalten Sie die Länge der verknüpften Liste. Die verknüpfte Liste ist leer, k ist 0, k ist 1, k ist größer als die Anzahl der Knoten in der verlinkten Liste
). Die zeitliche Komplexität ist O (n) und die allgemeine Idee lautet wie folgt:
public int findlastnode (int index) {// Index repräsentiert den Knoten des Index bis zum Ende.//Die zum ersten Mal, als ich durchquerte, habe ich die Länge der verlinkten Liste erhalten, wenn (head == null) {return -1; Current = Kopf; I <Größe - INDEX;Was soll ich tun, wenn der Interviewer Sie nicht erlaubt, die Länge der verlinkten Liste zu durchqueren? Als nächstes ist.
3.2 Verbesserungsideen: (Diese Idee wird auch in anderen Fragen verwendet)
Hier müssen Sie zwei Zeiger deklarieren: Das heißt, zuerst die beiden Knotenvariablen. Zuerst wird durch K-1-Positionen getrennt, und dann werden die beiden Knoten als Ganzes nach hinten bewegt, bis der zweite Knoten den letzten Knoten erreicht. Die Position, auf die der erste Knoten zeigt Knoten. Zeitkomplexität ist o (n)
Code -Implementierung: (erste Version)
public node findlastnode (Knotenkopf, Index) {if (node == null) {return null; 0; = Sekunde.Next;Code -Implementierung: (endgültige Version) (werfen Sie eine Ausnahme aus, wenn k größer ist als die Anzahl der Knoten in der verknüpften Liste)
Im obigen Code scheint die Funktion implementiert worden zu sein, ist aber nicht robust genug:
Achten Sie auf die Situation, in der K gleich 0 ist;
Wenn k größer als die Anzahl der Knoten in der verlinkten Liste ist, wird eine Ausnahme von Nullzeiger gemeldet, sodass hier ein Urteil erforderlich ist.
Der Kerncode lautet wie folgt:
public node findlastnode (Knotenkopf, int k) {if (k == 0 || head == null) {return null; Position für (int i = 0; i <k - 1; i ++) {system.out.println ("I's Wert"+i); Der Wert von k ist bereits größer als die Länge der verknüpften Liste // neue Nullpointerexception ("Die Länge der verlinkten Liste ist weniger als" + k). NULL; Der zweite Knoten erreicht den letzten Knoten zu diesem Zeitpunkt, auf den der Knoten der Knoten zeigt, nach dem wir suchen.4. Ermitteln Sie die Zwischenknoten in einer einzigen verknüpften Liste:
In ähnlicher Weise können Sie mit dem Interviewer die Länge der verlinkten Liste nicht berechnen.
Ideen:
Wie der zweite Abschnitt oben werden zwei Zeiger an erster und zweiter und zweiter eingestellt, aber hier gehen die beiden Zeiger gleichzeitig vor Am letzten Knoten ist der Knoten, auf den der erste Zeiger zeigt, der Zwischenknoten. Beachten Sie, dass die verknüpfte Liste leer ist und die Anzahl der Knoten der verknüpften Liste 1 und 2 beträgt. Die zeitliche Komplexität ist o (n).
Code -Implementierung:
// Methode: Finden Sie den Zwischenknoten der verlinkten Liste öffentlicher Knoten (Node Head) {if (head == null) {return null; Zweites Ende bewegt sich der Punkt zwei Ziffern, der erste Knoten bewegt sich um eine Zeit (zweite! Zu diesem Zeitpunkt ist die Position, auf die der erste Zeiger zeigt, die Position des Zwischenknotens zuerst zurück;In dem obigen Code ist der erhaltene Zwischenknoten, wenn n eine gleichmäßige Zahl ist, N/2 + 1 -Knoten. Wenn beispielsweise 6 Knoten in der verknüpften Liste vorhanden sind, wird der vierte Knoten erhalten.
5. Zusammenführen zwei bestellte einköpfige Listen, und die kombinierten verknüpften Listen sind noch in Ordnung:
Diese Frage wird häufig von verschiedenen Unternehmen untersucht.
Zum Beispiel:
Liste 1:
1-> 2-> 3-> 4
Liste 2:
2-> 3-> 4-> 5
Nach dem Zusammenführen:
1-> 2-> 2-> 3-> 3-> 4-> 4-> 5
Problemlösung:
Vergleichen Sie die verknüpfte Liste 1 und die verknüpfte Liste 2 nebeneinander.
Dies ähnelt der Zusammenführungssortierung. Achten Sie besonders auf die Situation, in der beide verknüpften Listen leer sind und einer von ihnen leer ist. Es ist nur o (1) Platz erforderlich. Zeitkomplexität ist O (max (Len1, Len2))
Code -Implementierung:
// Die beiden Parameter repräsentieren die Headerknoten der beiden verknüpften Listen für öffentliche Knoten MergelinkList (Knoten Head1, Knoten Head2) {if (head1 == null && head2 == null) {// Wenn beide verlinkten Listen leer sind, return null; if (head1 == null) {return head2; LISTE // Am Anfang lassen wir den aktuellen Knoten auf die kleineren Daten in Head1 und Head2 hinweisen, und erhalten den Kopfknoten, wenn (head1.data <head2.data) {head = head1; Weiter;} else {head2; ; // In der neuen verlinkten Liste entspricht der nächste Knoten des aktuellen Zeigers dem kleineren Datenstrom Current.Next; (Head2!Codetest:
public static void main (string [] args) {linkList list1 = new linkList (); (i);} für (int i = 3; i <8; i ++) {list2.add (i); );Die im obigen Code verwendete Methode für Hinzufügen und Druckmethoden stimmen mit dem Unterabschnitt 1 überein.
Laufeffekt:
HINWEIS: Die Lösung ist im "Schwert-Point-Angebot" rekursiv, was sich ein bisschen schwer zu verstehen anfühlt.
6. Inversion der einköpfigen Liste: [Die höchste Häufigkeit des Auftretens]
Zum Beispiel verknüpfte Liste:
1-> 2-> 3-> 4
Nach der Inversion:
4-> 2-> 2-> 1
Ideen:
Iterieren Sie die ursprüngliche verlinkte Liste von Anfang bis Ende, und jeder Knoten wird durchquert und wird entfernt und am vorderen Ende der neuen verknüpften Liste platziert. Beachten Sie, dass die verknüpfte Liste leer ist und es nur einen Knoten gibt. Zeitkomplexität ist o (n)
Methode 1: (Traversal)
// Methode: Umkehrung der verknüpften Liste der öffentliche Knoten -Reverselist (Knotenkopf) {// Wenn die verknüpfte Liste leer ist oder nur ein Knoten vorhanden ist, ist keine Inversion erforderlich, und der Kopfknoten der ursprünglichen verknüpften Liste wird direkt an die zurückgegeben. Originalverbindliche Liste (head == null || Der Header der neuen verlinkten Liste nach Inversion (aktuell! = Null) {next = current.Next; Nächster Knoten von Strom an den Header -Knoten der neuen verlinkten List -Revershead = Current;Im obigen Code ist der Kerncode Zeilen 16 und 17.
Methode 2: (Rekursion)
Diese Methode ist ein bisschen schwierig, also werde ich vorerst nicht darüber sprechen.
7. Drucken Sie eine einzige verknüpfte Liste von Ende zu Ende:
Für diese Art von invertierter Ordnung sollten wir an Stack denken, zuerst in und zuerst. Daher verwendet diese Frage entweder den Stapel selbst oder lässt das System den Stapel verwenden, dh rekursiv. Achten Sie auf den Fall, in dem die verknüpfte Liste leer ist. Zeitkomplexität ist o (n)
HINWEIS: Denken Sie nicht an die einzelne verknüpfte Liste und durchqueren Sie dann die Ausgabe.
Methode 1: (Erstellen Sie selbst einen neuen Stapel)
// Methode: Drucken Sie eine einzelne verlinkte Liste vom Ende bis zum Ende öffentlicher void Reverse (Knotenkopf) {if (head == null) {return; Erstellen Sie einen neuen Stapelknoten-Rent = Kopf; // Drücken Sie den Stapel des Knotens aus (stack.size ()> 0) {System.out.println (stack.pop ().Methode 2: (Verwenden Sie den Systemstapel: rekursive, elegante und prägnante Code)
public void reverseprint (Knotenkopf) {if (head == null) {return;Zusammenfassung: Methode 2 basiert auf der Rekursionsimplementierung. Der explizite Stapel von Methode 1 wird basierend auf Schleifen implementiert und der Code ist robuster.
8. Bestimmen Sie, ob eine einzige verknüpfte Liste einen Ring hat:
Hier werden auch zwei Zeiger verwendet.
Daher verwenden wir zwei Zeiger, um zu durchqueren: Der erste Zeiger macht jeweils einen Schritt, und der zweite Zeiger macht jeweils zwei Schritte. Die zeitliche Komplexität ist o (n).
Verfahren:
// Methode: Bestimmen Sie, ob eine einzelne verlinkte Liste einen Ringpublikum boolean Hascycle (Node Head) hat {if (head == null) {return false; ) {first. First.Next; ein Ring zurückgeben;Vollversionscode: (einschließlich Testteil)
Hier müssen wir auch eine überladene Methode zum Hinzufügen (Knotenknoten) hinzufügen, die beim Erstellen einer einseitigen, kreisförmigen Liste verwendet werden sollte.
LinkList.java: öffentliche Klasse LinkList {öffentlicher Knoten; ll) { / /Wenn der Header -Knoten leer ist, bedeutet dies, dass die verlinkte Liste noch nicht erstellt wurde. Erstellen Sie einen neuen Knoten, platzieren Sie ihn hinter dem aktuellen Knoten (korrelieren Sie den neuen Knoten mit der verknüpften Liste). ; ;} else {current.n ext = node; Node Node) {if (node == null) {return; Methode: Erkennen Sie, ob eine einzelne verlinkte Liste einen Ringpublikum boolean Hascycle (n ode Head) {if (head == null) {return false; First = First.Next; List hat eine Ringrückgabe true; Int Data; Daten in LinkList für (int i = 0; i <4; i ++) {list.add (i); ist eine Schleife in der verlinkten Liste. Hinweis: Die zu diesem Zeitpunkt erhaltene Struktur des Ringes ist die Struktur von Abbildung 1 im folgenden Abschnitt 8. System.out.println (list.hascycle (list.head));Der Code, der erkennt, ob eine einzige verknüpfte Liste einen Ring hat, ist Zeile 50.
Zeile 88: Wir fügen den Header -Knoten weiterhin zur verlinkten Liste hinzu, und die einzelne verknüpfte Liste wird zu diesem Zeitpunkt geschoben. Der endgültige Laufeffekt ist wahr.
Wenn 88 Codezeilen gelöscht werden, hat die einzelne verknüpfte Liste zu diesem Zeitpunkt keine Schleifen und der laufende Effekt ist falsch.
9. Nehmen Sie die ringlinkende Liste heraus, die Länge des Rings:
Die Linkliste, auf die wir normalerweise begegnen, lautet Folgendes: (Abbildung 1)
Die Länge des Rings im obigen Bild beträgt 4.
Es ist jedoch möglich, dass das Folgende auch Folgendes ist: (Abbildung 2)
Zu diesem Zeitpunkt beträgt die Länge des Rings im obigen Bild 3.
Wie finden Sie die Länge des Rings?
Ideen:
Hier müssen wir zuerst die Hascycle -Methode in Abschnitt 7 verwenden (die Methode, um festzustellen, ob ein Ring in der verknüpften Liste vorhanden ist). Es gibt den Wert für den Knoten zurück, in dem wir uns treffen. Dann können wir den Knoten erhalten, in dem wir uns treffen.
Verfahren:
// Methode: Bestimmen Sie, ob eine einzelne verknüpfte Liste einen Ring hat. Der zurückgegebene Knoten ist der Knoten, bei dem er öffentlichen Knoten hascycle (Knoten) {if (head == null) {return null; .Next; NULL; Der Parameterknoten repräsentiert den Knoten, in dem er öffentlich int begegnet ist (Knoten) {if (head == null) {return 0; Current.Next;Vollversionscode: (einschließlich Testteil)
öffentliche Klasse LinkList {Public Node Head; Der Knoten ist leer, dies bedeutet, dass die verknüpfte Liste noch nicht erstellt wurde, und zuordnen den neuen Knoten dem Header Knoten Head = New Node (Daten); Der aktuelle Knoten (korrelieren Sie den neuen Knoten mit der verknüpften Liste) Der aktuelle Knoten verweist auf den neu hinzugefügten Knoten}} // Methodenüberlastung: Fügen Sie der verknüpften Liste der verknüpfte Liste (Knotenknoten) {if (node == null) {return; {head = node; Aus dem Knoten node void print (Knotenknoten) {if (node == null) {return;} current = node; Current.Next; First = Kopf; Linked List ist eine ringartige Rückgabe zuerst; Der Parameterknoten repräsentiert den Knoten, in dem er öffentlich int begegnet ist (Knoten) {if (head == null) {return 0; Current.Next; privat, weil die Berechtigungen von Private nur für diese Klasse zugänglich sind. Int Data; = NULL; ; Der Prozess ist die Struktur von Abbildung 2 in diesem Abschnitt Knoten current = list1.hascycle (list1.head); ));Laufeffekt:
Wenn der obige Testcode der Zeilen 104 bis 122 in Folgendes geändert wird: (dh die Struktur in Abbildung 2 in die Struktur in Abbildung 1 ändern).
public static void main (string [] args) {linkList list1 = new linkList (); (List1.head); HINWEIS: Die zu diesem Zeitpunkt erhaltene Struktur dieses Rings ist die Struktur von Abbildung 1 in diesem Abschnitt. Knoten current = list1.hascycle (list1.head);Auslaufergebnisse:
Wenn Sie die 8. Zeile im obigen Code löschen, hat die verknüpfte Liste keine Schleifen, sodass das Ergebnis des Ausführens 0 ist.
10. In der einzelnen verknüpften Liste der Ausgangspunkt des extrahierten Rings:
Die Linkliste, auf die wir normalerweise begegnen, lautet Folgendes: (Abbildung 1)
Der Startpunkt 1 des Rings im obigen Bild.
Es ist jedoch möglich, dass das Folgende auch Folgendes ist: (Abbildung 2)
Zu diesem Zeitpunkt beträgt der Ausgangspunkt des Rings im obigen Bild 2.
Methode 1:
Hier müssen wir die Methode verwenden, um die Länge des Rings in Abschnitt 8 oben zu entfernen, um die Cyclelength zu erhalten, und diese Methode verwenden, um die Länge des Rings zu erhalten. Nachdem der Ring die Länge des Rings erhalten hat, müssen zwei Zeigervariablen zuerst verwendet werden. Treffen Sie, der Knoten, wenn sie sich treffen.
Hinweis: Um den Ausgangspunkt des Rings zu finden, müssen wir zunächst die Länge des Rings erhalten, und um die Länge des Rings zu erhalten, müssen wir zunächst feststellen, ob es einen Ring gibt. Hier werden also drei Methoden verwendet.
Code -Implementierung:
Kerncode für Methode 1:
// Methode: Holen Sie sich den Startpunkt des Rings. Die Parameterlänge repräsentiert die Länge des öffentlichen Knotens GetCyclestart (Knotenkopf, Int Cyclelength) {if (head == null) {return null; zum Längenschritt für (int i = 0; i <cyclelength; i ++) {Second = Second.Next; ! = null) {First.Next; Null zurückkehren;Vollversionscode: (einschließlich Testteil)
Public Class LinkList {öffentlicher Knoten; Der Knoten ist leer, dies bedeutet, dass die verknüpfte Liste noch nicht erstellt wurde, und zuordnen den neuen Knoten dem Header Knoten Head = New Node (Daten); Der aktuelle Knoten (korrelieren Sie den neuen Knoten mit der verknüpften Liste) Der aktuelle Knoten verweist auf den neu hinzugefügten Knoten}} // Methodenüberlastung: Fügen Sie der verknüpften Liste der verknüpfte Liste (Knotenknoten) {if (node == null) {return; {head = node; Aus dem Knoten node void print (Knotenknoten) {if (node == null) {return;} current = node; Current.Next; First = Kopf; Linked List ist eine ringartige Rückgabe zuerst; Der Parameterknoten repräsentiert den Knoten, in dem er öffentlich int begegnet ist (Knoten) {if (head == null) {return 0; Current.Next; Die Parameterlänge repräsentiert die Länge des öffentlichen Knotens GetCyclestart (Knotenkopf, Int Cyclelength) {if (head == null) {return null; zum Längenschritt für (int i = 0; i <cyclelength; i ++) {Second = Second.Next; ! = null) {First.Next; Null zurückgeben; Int Data; = NULL; ; Die Zeit ist die Struktur von Abbildung 2 in diesem Abschnitt Knotenstrom = List1.Hascycle (List1.head); .out.println ("Der Startpunkt des Rings ist" + list1.getCyclestart (List1.head, Länge) .Data);11. Bestimmen Sie den ersten Schnittpunkt, an dem sich zwei einköpfige Listen kreuzen:
"Die Schönheit der Programmierung" P193, 5.3, Interview Frage 37 hat diese Frage.
Während des Interviews ist die erste Reaktion vieler Menschen bei der Begegnung dieser Frage: Überqueren Sie jeden Knoten in der ersten verlinkten Liste. Wenn sich in der zweiten verknüpften Liste ein Knoten wie der Knoten in der ersten verlinkten Liste befindet, bedeutet dies, dass sich die beiden verknüpften Listen an diesem Knoten überlappen. Offensichtlich ist die Zeitkomplexität dieser Methode O (Len1 * Len2).
Methode 1: Die Idee der Verwendung von Stack
Wir können zwei verknüpfte Listen mit gemeinsamen Knoten sehen und teilweise überlappend, die topologische Form sieht aus wie ein Y, aber es kann kein X-förmiges sein. Wie in der Abbildung unten gezeigt:
Wie in der obigen Abbildung gezeigt, muss der letzte Knoten (Knoten 7), wenn eine einzelne verknüpfte Liste einen gemeinsamen Knoten hat Die nachfolgenden Knoten sind gleich.
Das Problem ist nun, dass wir in einer einzelnen verknüpften Liste nur nach den Anfangsknoten nacheinander durchlaufen und schließlich den Endknoten erreichen können. Der endgültige Heckknoten, der erreicht, klingt zuerst nach "im zuerst und dann" beenden "? Daher können wir uns vorstellen, die Eigenschaften des Stapels zu verwenden, um dieses Problem zu lösen: Die Knoten der beiden verknüpften Listen in zwei Stapel einfügen, damit sich die Endknoten der beiden verknüpften Listen oben in den beiden Stapeln befinden. Vergleichen wir eine Spitze des Stapels, bis der letzte identische Knoten gefunden wird.
Auf diese Weise müssen wir zwei Hilfsstapel verwenden, die Raumkomplexität ist O (Len1+Len2) und die zeitliche Komplexität O (Len1+Len2). Im Vergleich zur Brute -Force -Methode zu Beginn wurde die Zeiteffizienz verbessert, was dem Einsatz von Raumverbrauch für Zeiteffizienz entspricht.
Gibt es einen besseren Weg? Sprechen wir als nächstes darüber.
Methode 2: Bestimmen Sie den ersten Knoten, bei dem sich zwei verknüpfte Listen kreuzen: Verwenden Sie den schnellen und langsamen Zeiger, empfohlen (optimalere Lösung)
In der oben genannten Methode 2 liegt der Grund, warum wir den Stapel verwenden, darin, dass wir die Endknoten der beiden verknüpften Listen gleichzeitig erreichen möchten.其实为解决这个问题我们还有一个更简单的办法：首先遍历两个链表得到它们的长度。在第二次遍历的时候，在较长的链表上走|len1-len2| 步，接着再同时在两个链表上遍历，找到的第一个相同的结点就是它们的第一个交点。
这种思路的时间复杂度也是O(len1+len2)，但是我们不再需要辅助栈，因此提高了空间效率。当面试官肯定了我们的最后一种思路的时候，就可以动手写代码了。
核心代码：
//方法：求两个单链表相交的第一个交点public Node getFirstCommonNode(Node head1, Node head2) { if (head1 == null || head == null) { return null; } int length1 = getLength(head1); int length2 = getLength(head2); int lengthDif = 0; //两个链表长度的差值Node longHead; Node shortHead; //找出较长的那个链表if (length1 > length2) { longHead = head1; shortHead = head2; lengthDif = length1 - length2; } else { longHead = head2; shortHead = head1; lengthDif = length2 - length1; } //将较长的那个链表的指针向前走length个距离for (int i = 0; i < lengthDif; i++) { longHead = longHead.next; } //将两个链表的指针同时向前移动while (longHead != null && shortHead != null) { if (longHead == shortHead) { //第一个相同的结点就是相交的第一个结点return longHead; } longHead = longHead.next; shortHead = shortHead.next; } return null; } //方法：获取单链表的长度public int getLength(Node head) { if (head == null) { return 0; } int length = 0; Node current = head; while (current != null) { length++; current = current.next; } return length;以上就是有关java链表的经典面试题目，希望可以帮助大家顺利通过面试。