error de tiempo de ejecución: acceso de miembro dentro del puntero nulo del tipo 'struct ListNode' [solution.c]

Estoy tratando de resolver la pregunta de las listas ordenadas de merge k en leetcode usando la solución no recursiva. Cuando ejecuto el código da el error como se menciona a continuación. ¿Me pueden ayudar a resolver el problema? El error está en listas[min_idx] = listas[min_idx]->siguiente;

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* mergeKLists(struct ListNode** lists, int listsSize){
    
    struct ListNode *result;
    result = (struct ListNode *)malloc(sizeof(struct ListNode));
    result = NULL;
    struct ListNode *p;
    if (!listsSize){
        return result;
    }
    
    int min = INT_MAX;
    int min_idx = 0;
    int cnt=0;
    while (lists){
        for ( int i = 0 ; i<listsSize ; i++){
            if (lists[i]){
                cnt=0;
                if (lists[i]->val < min){
                    min = lists[i]->val;
                    min_idx = i;
                }
            }
            else {
                cnt++;
            }
        }
        if (cnt==listsSize){
            break;
        }
        
        struct ListNode *temp;
        temp = (struct ListNode *)malloc(sizeof(struct ListNode));
        temp->val = min;
        temp->next = NULL;
        if (result == NULL){
            result = temp;
            p = temp;
        }
        else {
            p->next = temp;
            p = p->next;
        }
        lists[min_idx] = lists[min_idx]->next;
    }
    return result;
}

ERROR:

Line 52: Char 40: runtime error: member access within null pointer of type 'struct ListNode' [solution.c]. 
Answer

Para empezar, incluso las dos primeras líneas producen una pérdida de memoria.

result = (struct ListNode *)malloc(sizeof(struct ListNode));
result = NULL;

Este ciclo while

while (lists){

puede ser un bucle infinito porque por convención este puntero no puede ser igual a NULL porque es un puntero al primer elemento de una matriz. Puede ser igual a NULL si el usuario especialmente pasará un puntero nulo a la función que contradice el requisito de la función.

Este fragmento de código

    for ( int i = 0 ; i<listsSize ; i++){
        if (lists[i]){
            cnt=0;
            if (lists[i]->val < min){
                min = lists[i]->val;
                min_idx = i;
            }
        }
        else {
            cnt++;
        }
    }
    if (cnt==listsSize){
        break;
    }

no está claro y, en esencia, no tiene sentido.

El enfoque sencillo puede verse, por ejemplo, de la siguiente manera

struct ListNode * mergeKLists( struct ListNode **lists, size_t listsSize )
{
    struct ListNode *head = NULL;
    struct ListNode **current = &head;

    int empty = 1;

    do
    {
        size_t i = 0;

        while ( i < listsSize && lists[i] == NULL ) i++;

        empty = i == listsSize;

        if ( !empty )
        {
            size_t min = i;
            
            while ( ++i != listsSize )
            {
                if ( lists[i] != NULL && lists[i]->val < lists[min]->val )
                {
                    min = i;
                }
            }

            *current = lists[min];
            lists[min] = lists[min]->next;
            ( *current )->next = NULL;
            current = &( *current )->next;              
        }
    } while ( !empty );

    return head;
}
  • combinar por parejas
  • divide y vencerás
  • (la matriz original se sobrescribirá; el resultado estará en lists[0])

#include <stddef.h>

struct ListNode {
        struct ListNode *next;
        int val;
        };


struct ListNode *mergeTwolists(struct ListNode *one, struct ListNode *two)
{
struct ListNode *result, **pp;

if (!one) return two;
if (!two) return one;

result = NULL;
for (pp = &result; one && two; pp = &(*pp)->next) {
        if (one->val <= two->val) { *pp = one; one = one->next; }
        else { *pp = two; two = two->next; }
        }
*pp = (one) ? one : two;
return result;
}

struct ListNode *mergeKLists(struct ListNode **lists, unsigned nlist)
{
unsigned src,dst;

for(    ; nlist > 1;    ) {                     // while there are pairs
        for (src=dst=0; src < nlist ; src+=2) { // combine pairwise
                if (src+1 >= nlist) lists[dst++] = lists[src];
                else lists[dst++] = mergeTwolists(lists[src], lists[src+1]);
                }
        nlist = dst;    // recurse
        }
return lists[0];
}