Inhalt
Vorwort:
Brüder, haben Sie jeden Tag eine Leber und fühlen Sie sich erfrischt! ! ! ! !
1. Verketten Sie Oberflächentestfragen, um festzustellen, ob die verknüpfte Liste ein Palindrom ist.
Problembeschreibung:
Brüder, seht euch das Bild an, um zu verstehen, was das Palindrom einer verknüpften Liste ist:
Palindromische Struktur: Lesen Sie 12 -> 23 -> 34 vorwärts, lesen Sie 12 -> 23 -> 34 rückwärts
Ungerade und gerade Zahlen sind in Ordnung:
Problemanalyse:
Um zu beurteilen, ob es sich um eine Palindromstruktur handelt, müssen wir die verknüpfte Liste einmal von vorne nach hinten, die andere von hinten nach vorne durchlaufen, die entsprechenden val-Werte sollten gleich sein, dann müssen wir den Zeiger der ändern verknüpfte Liste, hier verwenden wir die Geschwindigkeit. Der Zeiger hilft uns, den mittleren Knoten zu finden, den Zeiger vom mittleren Knoten zu ändern und mit der Traversierung zu beginnen, nachdem die Änderung abgeschlossen ist.
Problemerklärung:
Schritt 1: Um sicherzustellen, dass unsere verknüpfte Liste immer gefunden werden kann, definieren Sie eine Kopfvariable, die immer auf den Kopfknoten zeigt.
Schritt 2: Definieren Sie zwei Variablen, die beide am Anfang auf den Kopf zeigen, und finden Sie den Zwischenknoten mit Hilfe des schnellen und langsamen Zeigers.
Der dritte Schritt: Definieren Sie eine Cur-Variable, die auf den nächsten Knoten des Zwischenknotens zeigt, und lassen Sie die Cur-Variable den Zeiger ändern.
Schritt 4: Definieren Sie eine curNext-Variable gleich cur.Next, um zu verhindern, dass die nachfolgenden Knoten nach dem Ändern des Zeigers gefunden werden.
Code:
public boolean chkPalindrome(ListNode head) { if(head == null) return false;//判断一下链表是不是空，空的话直接返回false ListNode fast = head;//快指针fast，初始等于head ListNode slow = head;//慢指针slow，初始等于head while(fast != null && fast.next != null){//如果链表是奇数，fast.next == null停下，如果链表是偶数fast == null停下 fast = fast.next.next;//fast走两步 slow = slow.next;//slow走一步 } ListNode cur = slow.next;//cur等于slow的下一个节点 while(cur != null){//cur不为空开始反转 ListNode curNext = cur.next;//curNext等于cur的下一个节点 cur.next = slow;//开始反转 slow = cur;//反转完了后让slow等于cur cur = curNext;//cur再往后走一步。 } while(head != slow){//判断是不是回文结构 if(head.val != slow.val){//不是回文结构 return false; } if(head.next == slow){//偶数链表的情况 return true; } head = head.next; slow = slow.next; } return true; }
Zweitens geben die Kettenoberflächen-Testfragen zwei verknüpfte Listen ein und finden ihren ersten gemeinsamen Knoten.
Problembeschreibung:
Problemanalyse:
Richter:
1. Wenn sich zwei verknüpfte Listen schneiden, ist es dann eine Y- oder X-Form? Y
2. Wenn sich zwei verknüpfte Listen überschneiden, ist das Wertwertfeld dasselbe oder das nächste Feld dasselbe?Das nächste Feld ist dasselbe
Die obige Abbildung ist die sich überschneidende verkettete Liste.
Problemerklärung:
Schritt 1: Definieren Sie zunächst zwei Byte-Variablen, die auf die Köpfe der beiden verknüpften Listen zeigen, headA und headB.
Schritt 2: Definieren Sie zwei Variablen, um den Unterschied zwischen den beiden verknüpften Listen zu finden.
Schritt 3: Definieren Sie zwei weitere Byte-Variablen ps und pl, die jeweils auf headA und headB zeigen.
Schritt 4: Lassen Sie die lange verknüpfte Liste zuerst ihre unterschiedlichen Schritte ausführen.
Schritt 5: Die beiden verknüpften Listen gehören zusammen.
Schritt 6: Wenn ps = pl, ist es ein gemeinsamer Knoten.
Code:
public ListNode getIntersectionNode(ListNode headA, ListNode headB) { if(headB == null || headA == null) return null;//判断其中一条链表的头节点为空就是没有焦点 ListNode ps = headA; ListNode pl = headB; int lenA = 0; int lenB = 0; while(ps != null){求出ps链表的长度 lenA++; ps = ps.next; } ps = headA;//让ps重新等于头节点 while(pl != null){求出pl链表的长度 lenB++; pl = pl.next; } pl = headB;//让pl重新等于头节点 int len = lenA - lenB; if(len < 0){//判断ps长还是pl长 ps = headB; pl = headA; len = lenB - lenA; } while(len != 0)//求两条链表的差值 ps = ps.next; len--; } while(ps != pl){ ps = ps.next; pl = pl.next; } return ps; }
Täglicher Check-in: Derzeit aktualisieren wir die Fragen der verlinkten Liste. Wenn Sie an dieser Frage interessiert sind, können Sie mich privat kontaktieren. Wir können diskutieren und hart zusammenarbeiten.
