Why can't inverseList function be implemented？

The linked list realizes reversal through the stack, but does not jump when it runs to inverseList. Why can't inverseList function be implemented？

#include <cstdio>
#include <cstdlib>

typedef struct lnode{
    int data;
    struct lnode *next;
}lnode,*Linklist;

Linklist createList(int n){
    Linklist L,p,q;
    int i;
    L = (lnode*)malloc(sizeof(lnode));
    if(!L){
        return 0;
    }
    L->next = NULL;
    q = L;
    for(int i = 0; i < n; i++){
        p = (lnode*) malloc(sizeof(lnode));
        printf("enter：\n");
        scanf("%d",&p->data);
        p->next = NULL;
        q->next = p;
        q = p;
    }
    return L;
}

Linklist inverseList(Linklist h){
    Linklist res;
    int arr[10];
    int i=0;
    while(h->next != NULL){
        arr[i] = h->data;
        i++;
        h = h->next;
    }

    if(-1 == i){
        res->data = arr[i];
        i--;
        res = res->next;
    }
    return res;
}

void printList(Linklist h){
    Linklist p = h->next;
    while(p!=NULL){
        printf("%d ",p->data);
        p = p->next;
    }
}

int main(){
    Linklist pHead = NULL;
    int n;

    printf("enter the number of value:\n");
    scanf("%d",&n);
    pHead = createList(n);
    printf("value in the list：\n");
    printList(pHead);
    printf("\n----------\n");
    inverseList(pHead);
    printList(pHead);
    return 0;
}

The linked list realizes reversal through the stack, but does not jump when it runs to inverseList. Why can't inverseList function be implemented？

Your list can be treated as a stack.

To create a new list which is the reverse of an existing list, then iterate over the original list and add all values to the head of the new list. The new list is now the exact reverse of the first original list.

If you should reverse the original list, then do as above, then delete all nodes from the original list, and exchange the heads of the original and new list.

It seems you are compiling your program as a C++ program. These headers

#include <cstdio>
#include <cstdlib>

are C++ headers.

In C you need to write

#include <stdio.h>
#include <stdlib.h>

But in any case your code is entirely wrong.

For example the function createList creates a dummy first node with uninitialized data member data. So for example it is unclear when the list is empty: whether when the pointer to the head node is equal to NULL or when the list has a single dummy node. And moreover the uninitialized data member next is used within the function inverseList in this while loop

while(h->next != NULL){
    arr[i] = h->data;
    //...

The list shall not have a dummy node.

The function inverseList does not make sense. For example why within the function there is created an array with a magic number of elements. Or for example when this condition in the if statement

if(-1 == i){

is satisfied. Or why within the function there is used the uninitialized pointer res.

Linklist res;
//...
res->data = arr[i];

If the list does not contain a dummy node (and it shall not contain it) then the function inverseList can look very simply. For example

Linklist inverseList( Linklist head )
{
    Linklist new_head = NULL;

    while ( head != NULL )
    {
        current = head;
        head = head->next;
        current->next = new_head;
        new_head = current;
    }

    return new_head;
}

and in main you need to write

pHead = inverseList(pHead);