verknüpfte Liste (einfach)

Verknüpfte Liste (einfach) – Java

1. Geben Sie den Kopfknoten einer verknüpften Liste ein und geben Sie den Wert jedes Knotens vom Ende bis zum Kopf in umgekehrter Reihenfolge zurück (Rückgabe in einem Array).

Ursprünglicher Link: https://leetcode.cn/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof

Beispiel 1:

输入：head = [1,3,2]
输出：[2,3,1]

Grenze:

0 <= 链表长度 <= 10000

Interpretation des Themas:

Im Implementierungscode definiert ListNode, valbezieht es sich auf den an der aktuellen Position gespeicherten Wert, nextähnlich der Zeigerverwendung in der C-Sprache (dh ListNodedie an der nächsten Zeigerposition gespeicherten Typdaten).

Idee: (zweimal scannen)

1. Da das Array zurückgegeben wird, muss berechnet werden, headwie viele Daten sich im Array befinden, um die Länge des Arrays zu initialisieren.

2. Nachdem Sie die Länge des Arrays entsprechend der Anzahl der Daten initialisiert haben, fügen Sie headdie Daten direkt in umgekehrter Reihenfolge des Array-Index ein

Implementierungscode:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        ListNode node = head;
        int count = 0;
        while (node != null){
            count++;
            node = node.next;
        }
        int[] ints = new int[count];
        for (int j=count-1; j>=0; j--){
            ints[j] = head.val;
            head = head.next;
        }
        return ints;
    }
}

2. Definieren Sie eine Funktion, geben Sie den Kopfknoten einer verknüpften Liste ein, kehren Sie die verknüpfte Liste um und geben Sie den Kopfknoten der umgekehrten verknüpften Liste aus.

Ursprünglicher Link: https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof

Beispiel:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

Grenze:

0 <= 节点个数 <= 5000

Ideen:

1. Doppelzeigermethode

Wenn diese Frage mit Doppelzeigern analysiert wird, kann man verstehen, dass der Zeiger zu Beginn abwechselnd von 1 auf 5 und schließlich auf Null zeigt; das zu realisierende Endergebnis ist abwechselnd von 5 auf 1 und schließlich auf Null . Dies entspricht der Auswahl des aktuellen Elements nextals vorheriges Element.

Das heißt, die ursprüngliche 1 nextist 2, die 2 nextist 3...5 . Nachdem die verknüpfte Liste umgekehrt wurde, nextist die 1 , die 2 ist 1...5 ist 4nullnextnullnextnext

2. Rekursive Methode

Die rekursive Methode besteht darin, den Zeiger zunächst auf das vorletzte Element zu richten, dann nextauf sich selbst zu zeigen, wenn das letzte Element angegeben ist, und dann auf sein eigenes next zu zeigen. Anschließend nullendet das Programm, wenn es während des Backtracking-Prozesses 1 erreicht . Das Ideenanalysediagramm sieht wie folgt aus:

Implementierungscode:

// 双指针法
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode cur = head, pre = null;
        while(cur != null) {
            ListNode tmp = cur.next; // 暂存后继节点 cur.next
            cur.next = pre;          // 修改 next 引用指向
            pre = cur;               // pre 暂存 cur
            cur = tmp;               // cur 访问下一节点
        }
        return pre;
    }
}

// 递归法
class Solution {
    public ListNode reverseList(ListNode head) {
        while(head == null || head.next == null){
            return head;
        }
        ListNode node = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return node;
    }
}
/**
     * 递归法中难点：
     * head.next.next = head
     * 此处可以理解为：head.next = tmp; tmp.next = head
     * 即，将当前元素的下一元素指针逆转，原本是4->5,变为5->4
     * 
     * head.next = null
     * 可以理解为 4->null
     */

3. (Kopie einer komplexen verknüpften Liste) Bitte implementieren Sie die Funktion copyRandomList, um eine komplexe verknüpfte Liste zu kopieren. In einer komplexen verknüpften Liste verfügt jeder Knoten über einen nächsten Zeiger, der auf den nächsten Knoten zeigt, und einen zufälligen Zeiger, der auf einen beliebigen Knoten in der verknüpften Liste oder auf Null zeigt.

Beispiel 1:

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

Beispiel 2:

输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

Beispiel 3:

输出：[[3,null],[3,0],[3,null]]

Beispiel 4:

输入：head = []
输出：[]
解释：给定的链表为空（空指针），因此返回 null。

Ursprünglicher Link: https://leetcode.cn/problems/fu-za-lian-biao-de-fu-zhi-lcof

Interpretation des Themas:

Die eigentliche Bedeutung des Titels kann als Kopieren einer verknüpften Liste mit Objekten verstanden werden, alle Attribute des Objekts sind jedoch die Elementwerte in der verknüpften Liste.

Ideen:

Geben Sie mithilfe der Hash-Tabellenmethode zunächst die Werte der Knoten der verknüpften Liste nacheinander in den entsprechenden Knoten ein Mapund weisen Sie dann die Knoten nextund randomAttribute dem neuen Knoten zu.

Implementierungscode:

/*
// Definition for a Node.
class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
*/
class Solution {
    public Node copyRandomList(Node head) {
        if (head == null){
            return null;
        }
        Node cur = head;
        Map<Node, Node> map =  new HashMap<>();
        while (cur != null) {
            map.put(cur, new Node(cur.val));
            cur = cur.next;
        }
        cur = head;
        while (cur != null){
            map.get(cur).next = map.get(cur.next);
            map.get(cur).random = map.get(cur.random);
            cur = cur.next;
        }
        return map.get(head);
    }
}