LeetCode //C - 25. Nodos inversos en el grupo k

25. Nodos inversos en el grupo k

Dado el encabezado de una lista vinculada, invierta los nodos de la lista k a la vez y devuelva la lista modificada.

k es un número entero positivo y es menor o igual a la longitud de la lista vinculada. Si el número de nodos no es múltiplo de k, entonces los nodos excluidos, al final, deberían permanecer como están.

No puede alterar los valores en los nodos de la lista, solo se pueden cambiar los nodos mismos.
 

Ejemplo 1:

Entrada: cabeza = [1,2,3,4,5], k = 2
Salida: [2,1,4,3,5]

Ejemplo 2:

Entrada: cabeza = [1,2,3,4,5], k = 3
Salida: [3,2,1,4,5]

Restricciones:

• El número de nodos en la lista es n.
• 1 <= k <= n <= 5000
• 0 <= Valor.nodo <= 1000

De: LeetCode
Enlace: 25. Nodos inversos en el grupo k

---

Solución:

Ideas:

Funciones clave:

1. inversa (struct ListNode* inicio, struct ListNode* fin): esta es una función auxiliar que invierte una sublista de una lista vinculada desde el inicio del nodo hasta el final del nodo, pero sin incluirlo.

2. ReverseKGroup (struct ListNode* head, int k): esta es la función principal que invierte los nodos en fragmentos del grupo k en una lista vinculada determinada.

Pasos clave:

1. Contando nodos: la función primero cuenta el número total de nodos en la lista vinculada.

2. Inicialización: se inicializan varios punteros para realizar un seguimiento de varias partes de la lista. Estos incluyen punteros para el final del grupo anterior (prev_group_end), el inicio y el final del grupo actual (group_start y group_end) y un nuevo encabezado para la lista (new_head).

3. Bucle principal: el bucle while principal se ejecuta siempre que queden al menos k nodos en la lista para revertir.

• Dentro del bucle, group_end se mueve para apuntar al k-ésimo nodo desde group_start.
• Se realiza una verificación nula para salir del bucle si group_end es NULL.
• Los nodos entre group_start y group_end luego se invierten utilizando la función inversa.
• El grupo invertido se conecta al grupo anterior o se establece como el nuevo encabezado de la lista.
• Los punteros se actualizan para pasar al siguiente grupo de nodos.

4. Conexión de nodos sobrantes: después de que se hayan invertido todos los grupos posibles de k nodos, los nodos restantes (menos de k) se conectan al último grupo invertido.

5. Retorno: Finalmente, la función devuelve el nuevo encabezado de la lista vinculada.

Código:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverse(struct ListNode* start, struct ListNode* end) {
    
    
    struct ListNode* prev = NULL;
    struct ListNode* curr = start;
    struct ListNode* next;
    
    while (curr != end) {
    
    
        if (curr == NULL) {
    
    
            break;
        }
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    
    return prev;
}

struct ListNode* reverseKGroup(struct ListNode* head, int k) {
    
    
    int count = 0;
    struct ListNode* tmp = head;
    while (tmp) {
    
    
        count++;
        tmp = tmp->next;
    }
    
    struct ListNode* prev_group_end = NULL;
    struct ListNode* new_head = NULL;
    struct ListNode* group_start = head;
    struct ListNode* group_end = head;
    
    while (count >= k) {
    
    
        for (int i = 1; i < k; i++) {
    
    
            if (group_end) {
    
    
                group_end = group_end->next;
            }
        }
        
        if (!group_end) {
    
    
            break;
        }
        
        struct ListNode* next_group_start = group_end->next;
        group_end->next = NULL;
        struct ListNode* reversed_group = reverse(group_start, next_group_start);
        
        if (prev_group_end) {
    
    
            prev_group_end->next = reversed_group;
        }
        
        if (!new_head) {
    
    
            new_head = reversed_group;
        }
        
        prev_group_end = group_start;
        group_start = next_group_start;
        group_end = next_group_start;
        
        count -= k;
    }
    
    if (prev_group_end) {
    
    
        prev_group_end->next = group_start;
    }
    
    return new_head ? new_head : head;
}