1. Darle una lista enlazada de longitud n, cada nodo contiene un puntero aleatorio adicional aleatorio, que puede apuntar a cualquier nodo en la lista enlazada o a un nodo vacío.
Construye una copia profunda de esta lista enlazada. Una copia profunda debe constar de exactamente n nuevos nodos, donde el valor de cada nuevo nodo se establece en el valor de su correspondiente nodo original. El siguiente puntero y el puntero aleatorio del nuevo nodo también deben apuntar al nuevo nodo en la lista enlazada copiada, de modo que estos punteros en la lista enlazada original y la lista enlazada copiada puedan representar el mismo estado de lista enlazada. Ninguno de los punteros de la lista enlazada copiada debe apuntar a los nodos de la lista enlazada original.
Por ejemplo, si hay dos nodos X e Y en la lista enlazada original, donde X.random --> Y . Luego, los dos nodos x e y correspondientes en la lista vinculada de replicación también tienen x.random --> y .
Devuelve el nodo principal de la lista vinculada replicada.
Una lista enlazada en entrada/salida está representada por una lista enlazada de n nodos. Cada nodo está representado por un [val, random_index]:
val: un número entero que representa Node.val.
random_index: el índice del nodo al que apunta el puntero aleatorio (que va de 0 a n-1); nulo si no apunta a ningún nodo.
Su código solo acepta el nodo principal de la lista vinculada original como parámetro entrante. La fuente de la pregunta de prueba: el código LeetCode
y su explicación son las siguientes:
1. Hay muchas maneras de resolver este problema. Aquí usamos el método de enlazar la nueva lista enlazada para recorrer juntos: (hay tres procesos en total) como se muestra a continuación:
/**
* Definition for a Node.
* struct Node {
* int val;
* struct Node *next;
* struct Node *random;
* };
*/
typedef struct Node node;
struct Node* copyRandomList(struct Node* head) {
if (NULL == head) {
return NULL;
}
node* cur = head;
while (cur != NULL) {//这个循环用来创建新结点并连接原链表
node* new_node = (node*)malloc(sizeof(node));
new_node->val = cur->val;
new_node->next = cur->next;
cur->next = new_node;
cur = new_node->next;
}
node* temp = head;
node* head2 = head->next;
while (1) {//该循环在遍历原链表的同时跟随原链表一起遍历新链表,找到每一个的
//随机指针random的位置进行相应存储
//总共遍历所有元素
node* cur1 = head;
node* cur2 = head->next;
while (cur1 != temp->random) {//每个元素的random都要在整段链表中遍历,
//来寻找对应的地址.
cur1 = cur1->next->next;
if (NULL == cur1) {
cur2 = cur2->next;
break;
}
cur2 = cur2->next->next;
}
head2->random = cur2;
temp = temp->next->next;
if (NULL == temp) {
break;
}
head2 = head2->next->next;
}
node* node_1 = head;
node* node_2 = head->next;
node* new_head_node = head->next;
while (node_2->next != NULL) {//遍历完之后新的链表的每个结点的random都指向了
//相应的地方,这时断开链表.
node_1->next = node_2->next;
node_2->next = node_1->next->next;
node_1 = node_1->next;
node_2 = node_2->next;
}
node_1->next = NULL;
return new_head_node;//返回新链表的首节点地址
}