Intercambio por pares de nodos en la lista vinculada: nodo principal virtual

24 Intercambio por pares de nodos en la lista enlazada – nodo principal virtual

A través de esta pregunta podrás:

1. Aumentar la comprensión de los nodos principales virtuales.

2. Fortalezca su comprensión de las operaciones básicas de las listas enlazadas, una estructura de datos básica.

1. Proceso de intercambio:

Como se muestra en la figura, suponga que la lista vinculada es como se muestra en la figura.

Para reducir la discusión por separado sobre el nodo principal, aquí se utiliza un nodo principal virtual para el procesamiento.

Como se muestra en la figura, cada vez que el "puntero actual" apunta al nodo anterior del "par de nodos de intercambio" actual, esto evita una discusión separada del nodo principal en forma de "nodo principal virtual". El proceso de intercambio específico se muestra en la figura:

2. Dificultades:

1. Condición de terminación del bucle:

   Si la longitud de la lista vinculada es un número par, el "puntero más actual" apuntará al nodo 4 y no habrá un siguiente "par de nodos de intercambio". En este momento, la condición de terminación esp->next==NULL

   Si la longitud de la lista vinculada es un número impar, el "puntero más actual" apuntará al nodo 4 y quedará un nodo. No es necesario procesar este nodo. En este momento, la condición de terminación esp->next->next==NULL

2. Proceso de intercambio:

   Tome el primer intercambio como ejemplo:

   Durante el proceso de intercambio, los nodos 1 y 2 se desconectarán, por lo que es necesario guardarlos con antelación.

    while(p->next && p->next->next){
         
         
           ListNode* nextP = p->next;  // 保存第一个待交换对的第一个节点
           ListNode* nextNextP = p->next->next->next;  // 保存第二个待交换对的第一个节点
           p->next = p->next->next;  // 完成步骤一
           p->next->next = nextP;  // 完成步骤二
           nextP->next = nextNextP; // 完成步骤三
           p = p->next->next;  // 更新p到下一个交换节点对的前一个节点（当前交换节点对的第二个节点）
       }
   

3. Código:

 ListNode* swapPairs(ListNode* head) {
    
       
     ListNode* dummyHead = new ListNode();
     dummyHead->next = head;
     ListNode* p = dummyHead;
     while(p->next && p->next->next){
    
    
         ListNode* next1P = p->next;  // 保存第一个待交换对的第一个节点
         ListNode* next3P = p->next->next->next;  // 保存第二个待交换对的第一个节点
         p->next = p->next->next;  // 完成步骤一
         p->next->next = next1P;  // 完成步骤二
         next1P->next = next3P; // 完成步骤三
         p = p->next->next;  // 更新p到下一个交换节点对的前一个节点（当前交换节点对的第二个节点）
     }
     ListNode* temp = dummyHead->next;
     delete dummyHead;
     return temp;
 }