LeetCode fait référence à l'offre 35. Copie d'une liste chaînée complexe

Idées originales de lien de titre :

1. Cette question n'a même intuitivement besoin d'aucun algorithme, suivez simplement l'idée générale de copie, ouvrez un nouvel espace, puis copiez la valeur du nœud correspondant, ne regardez pas d'abord au hasard.
2. La chose gênante est que Node-> points aléatoires au hasard, et il n'y a pas de règle à suivre.
3. J'ai donc pensé à trouver le décalage de chaque nœud aléatoire par rapport au nœud principal, à trouver le nœud aléatoire dans le décalage correspondant dans la nouvelle liste liée et à le pointer.
4. Au début, je pensais que le temps serait écoulé, mais le résultat était bon, 54% du temps et 60% de la mémoire.
5. Le mauvais point est que beaucoup de pointeurs sont utilisés pour indiquer la position, ce qui est un peu brouillon, et l'idée simple est de payer un prix ha ha ha ha.
   Donnez le code:

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
    
    
public:
    Node* copyRandomList(Node* head) {
    
    
            if(head == NULL) return NULL;
    Node* current = NULL;
    current = head;
    Node *result = NULL;
    Node *newHead = NULL;
    result = new Node(head->val);
    newHead = result;
    while(current != NULL){
    
    
        Node* midNode = new Node(-1);
        if(current->next != NULL){
    
    
            result->next = midNode;
        }
        result->val = current->val;
        current = current->next; 
        result = result->next;       
    }
    current = head;
    result = newHead;
    Node *subRandom;
    Node *oldCurrent;
    oldCurrent = head;
    subRandom = newHead;
    while(current != NULL){
    
    
        if(current->random == NULL){
    
    
            subRandom->random = NULL;
        }else{
    
    
            int i = 0;
            Node *subCurrent;
            subCurrent = current->random;
            while(oldCurrent != subCurrent){
    
      //在这里找当前节点的random的偏移量
                i++;
                oldCurrent = oldCurrent->next;
            }
            while(i>0){
    
         //去找新链表中的对应偏移量下的节点
                result = result->next;
                i--;
            }
            subRandom->random = result;
        }
        subRandom = subRandom->next;
        result = newHead;
        current = current->next;
        oldCurrent = head;
        
    }
    return newHead;
    }
};

≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈≈≈≈≈≈≈≈≈≈≈ 1.
Regardez la méthode de résolution de problèmes dans les commentaires, plus l'utilisation de unordered_map est avancée
pour réduire un beaucoup de frais généraux de traversée

2. Bien sûr, il existe des méthodes dans le livre d'offres.
La description de cette méthode est la suivante:

1. La copie d'un nœud identique au nœud derrière chaque nœud de la liste liée d'origine détruit la structure de la liste liée d'origine. Indique que les éléments récurrents adjacents, le premier est l'ancien élément et le dernier est le nouvel élément.
2. Sur la longue liste chaînée nouvellement formée, utilisez la relation aléatoire dans la liste chaînée d'origine pour définir le caractère aléatoire de chaque nouveau nœud.
3. Restaurez la liste liée d'origine et coupez tous les nouveaux nœuds de la longue liste liée pour former une liste liée correctement copiée.
   Ce genre de réflexion vaut vraiment la peine d'être appris! ! !