为什么我的代码给我乱码，有时出现分段错误？

Question

I'm trying to make an implementation of merge() given 2 sorted linked lists, and output a linked list that merges the two and is sorted. I first create an array and put the items there, but when I print the array elements I get garbage values/seg fault. I know it's a lot of code to go through but I'd really appreciate anyone who can help :)

typedef struct _node {
    int data;
    struct _node * next;
} node_t;

typedef struct {
    node_t * head;
    node_t * tail;
} LL_t;

LL_t* createList(int num_nodes);
void printList(LL_t* L);
void merge(LL_t * L, LL_t * L2);

void merge(LL_t * L, LL_t * L2){
    if(L2->head==NULL){ // empty L2
        free(L2);
        return;
    }
    else if(L->head==NULL){ // empty L1
        *L=*L2;
        free(L2);
        return;
    }

    node_t* node=L->head;
    int mid=0;
    if(node->next!=NULL){
    for (mid=0; node->next!=NULL; mid++) //finds last index of L1
        node=node->next;
    }

    L->tail->next=L2->head;
    L->tail=L2->tail;
    node_t* ind = L->head;
    free(L2);
    int len=0;
    for (len=0; ind!=NULL; len++) // finds num of items in list
        ind=ind->next;

    int arr[len];
    int newarr[len];
    node_t* cur= L->head;

    for(int i=0; cur!=NULL; i++){ // creates array with list items
        arr[i]=cur->data;
        cur=cur->next;
    }

    int first=0;
    int last=len;
    int leftpos=0;
    int rightpos=mid+1;
    int newpos=0;


    //  insert elements to arr until a half of the array
    //  reaches mid or last
    while(leftpos<=mid && rightpos<=last-1){
        if(arr[leftpos]<arr[rightpos]){
            newarr[newpos++]=arr[leftpos++];
        }
        else
            newarr[newpos++]=arr[rightpos++];
    }

    // fills in the rest of the array
    while(leftpos<=mid)
        newarr[newpos++]=arr[leftpos++];
    while(rightpos<=last)
        newarr[newpos++]=arr[leftpos++];
    for(int j=0; j<len; j++)
        printf("newarr=%d\n",newarr[j]); 

    }

int main(void){
    int num_nodes = 4;
    int num_nodes2 = 3;
    LL_t* L=createList(num_nodes);
    LL_t* L2=createList(num_nodes2);
    merge(L, L2);

}
// Creates the list. No problem here
LL_t* createList(int num_nodes){
    LL_t* L = malloc(sizeof(LL_t));
    L->head=NULL;
    L->tail=NULL;
    node_t *n;
    int i=0;
    for (i = 0; i < num_nodes; i++) {
        n = malloc(sizeof(*n));
        scanf("%d",&n->data);
        n->next = NULL;
        if (L->head == NULL){
            L->head = n;
            L->tail = n;
        } 
        else {
            L->tail->next = n;
            L->tail = n;
        }
    }
    puts("\n");
    return L;
    }

Answer 1

The problem is here in the merge() :

while(rightpos<=last)
    newarr[newpos++]=arr[leftpos++];
                         ^^^^^^^

Here, the condition of while loop is rightpos<=last but accessing leftpos index element of arr and incrementing it. And if rightpos is less than last then the while loop condition will always be true which makes it an infinite loop. Every iteration of while loop is incrementing leftpos , at one stage its value will be greater than the size of array arr and accessing the array element beyond the size of the array is undefined behavior which includes program may give segmentation fault. It should be:

while(rightpos<=last)
    newarr[newpos++]=arr[rightpos++];