warning: passing argument 1 of 'HashInsertar' from incompatible pointer type

You have encountered a recurring error in StackOverflow in Spanish motivated by the misuse of type aliases and the mixing of concepts.

The nodes are not lists.

In the code you have given, you define the struct nodoL object, then name the pointer to this object as lista . And that is as wrong as saying that a step is a ladder, sincerely Do you think the same ?:

This erroneous nomenclature makes it difficult to reason about the code and that it is difficult to follow and debug, since the alias not only hides the underlying type but also gives it a semantic meaning that it lacks.

Thus: lista is not a list of elements, it is a pointer to a struct nodoL . Taking into account the correct concepts, this other alias:

typedef lista Hash[HASHMAX];

It does not make Hash a training 1 of HASHMAX lists, but it is a formation of HASHMAX pointers to struct nodoL .

Things by name.

If we now name things by their names, we will see why you are receiving the error you describe, the function HashInsertar :

void HashInsertar(Hash *H, int e);

It is not a function that receives a pointer to Hash and an integer ( int ) but a function that receives a pointer to a formation of HASHMAX pointers to struct nodoL , in the call that It produces error:

HashInsertar(&milista,numNuevo);

You feed the function with the memory address of milista , which has been defined as follows:

lista milista=NULL;

The variable milista is not a list of elements but it is a pointer to struct nodoL , applying the operator address we get a pointer to a pointer to struct nodoL while HashInsertar expects a pointer to a formation of HASHMAX pointers to struct nodoL : it is clearly receiving a different data than expected:

| SÍMBOLO  | DESCRIPCIÓN                                            | TIPO               |
+----------+--------------------------------------------------------+--------------------+
| &milista | puntero a puntero a struct nodoL                       | nodoL**            |
| Hash *   | puntero a formación de HASHMAX punteros a struct nodoL | (nodoL*[HASHMAX])* |

Proposal.

To avoid these confusions, call things by their names, creating additional types if necessary:

typedef struct nodoL {
    int info;
    struct nodoL * sig;
} nodoL;

typedef struct lista {
    nodoL * raiz;
} lista;

typedef struct Hash {
    lista tabla[HASHMAX];
} Hash;

With these types clearly differentiated, you must make changes to your code:

void enlistar (lista *L, int n) {
    nodoL *punto_de_insercion = L -> raiz;

    if (punto_de_insercion) {
        while (punto_de_insercion -> sig) {
            punto_de_insercion = punto_de_insercion -> sig;
        }
        punto_de_insercion -> sig = (nodoL *)malloc(sizeof(nodoL));
        punto_de_insercion = punto_de_insercion -> sig;
    } else {
        punto_de_insercion = (nodoL *)malloc(sizeof(nodoL));
    }

    punto_de_insercion -> info = n;
    punto_de_insercion -> sig = NULL;
}

void HashInsertar (Hash *H, int e){
    enlistar ((H -> tabla[HashClave(e)], e);
}

Note that I have not added any initialization or release routine (and I have written the routine enlistar without testing it), each of the types will need to be initialized and released, for example:

void crear_hash(Hash *H) {
    for (int i = 0; i < HASHMAX; ++i) {
        H -> tabla[i] = (lista *)malloc(sizeof(lista));
    }
}

void eliminar_hash(Hash *H) {
    for (int i = 0; i < HASHMAX; ++i) {
        eliminar_lista(H -> tabla[i]);
    }
}

Frankly it makes me quite logical that I give you that warning, after The entire HashInsertar function has the following prototype:

void HashInsertar(Hash *H, int e);

As a first argument, it receives a pointer to Hash. Meanwhile you in the main declares the milista variable as follows:

lista milista = NULL;

And try to pass it to the hash function:

HashInsertar(&milista, numNuevo);

How you antedate the & to "milista", you are passing a pointer to list to the function, while this keeps asking you for a pointer to Hash.

We are going to expand the definitions of both to see the difference:

A list is defined as:

typedef struct nodoL * lista;

that is:

(lista) ≡ (struct nodoL *)

Therefore a pointer to list would be a double pointer to struct nodeL:

(lista *) ≡ (struct nodoL **)

Meanwhile a hash is defined as:

typedef lista hash[HASHMAX];

In other words, the following is true:

(HASH) ≡ (lista [HASHMAX]) ≡ (struct nodoL * [HASHMAX])

So a hash pointer would be:

(HASH *) ≡ (lista * (*) [HASHMAX]) ≡ (struct nodoL * (*) [HASHMAX])

Then the pointer to list compared to the pointer to Hash:

(struct nodoL **) ≠ (struct nodoL * (*) [HASHMAX])
        (lista *) ≠ (lista (*)[HASHMAX])
        (lista *) ≠ (Hash *)