LeetCode se refiere a la Oferta 35. Copia de una lista vinculada compleja

Ideas de enlace de título original :

1. Esta pregunta, intuitivamente, ni siquiera necesita ningún algoritmo, simplemente siga la idea de copia general, abra un nuevo espacio y luego copie el valor del nodo correspondiente, no mire al azar primero.
2. Lo problemático es que Nodo-> puntos aleatorios al azar, y no hay una regla a seguir.
3. Así que pensé en encontrar el desplazamiento del azar de cada nodo en relación con el nodo principal, encontrar el nodo aleatorio en el desplazamiento correspondiente en la nueva lista vinculada y apuntarlo.
4. Al principio pensé que se agotaría, pero el resultado fue bueno, el 54% del tiempo y el 60% de la memoria.
5. Lo malo es que se usan muchos punteros para indicar la posición, lo cual es un poco desordenado, y la idea simple es pagar un precio ja ja ja ja.
   Dar el código:

/*
// 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
. Mira el método de resolución de problemas en los comentarios, cuanto más avanzado es el uso de unordered_map
para reducir un mucha sobrecarga transversal

2. Por supuesto que hay métodos en el libro Oferta.
La descripción de este método es:

1. Copiar un nodo que es el mismo que el nodo detrás de cada nodo de la lista vinculada original destruye la estructura de la lista vinculada original. Indica que los elementos repetidos adyacentes, el primero es el elemento antiguo y el segundo es el elemento nuevo.
2. En la lista larga enlazada recién formada, use la relación aleatoria en la lista enlazada original para establecer la aleatoriedad de cada nuevo nodo.
3. Restaure la lista enlazada original y corte todos los nodos nuevos de la lista enlazada larga para formar una lista enlazada copiada con éxito.
   ¡Realmente vale la pena aprender este tipo de pensamiento! ! !