Why does this 'b' linked list changed?

I have 2 linked lists:

'a': 1->2->3->null

'b': 4->5->null

I want to merge them together as : 1->4->2->5->3->null

I write a function:

    private void merge(ListNode a, ListNode b){
        ListNode cur = new ListNode(0);
        
        while(a != null && b != null){
            cur.next = a;
            cur = cur.next;
     
            cur.next = b;
            cur = cur.next;
            
            b=b.next;
            a=a.next;
        }
        if(a==null && b==null) return;
        else if(a==null){
            cur.next = b;
        }else if(b==null){
            cur.next = a;
        }
        return;
    }

what I think is to use a 'cur' to record each node in these 2 linked list 'a' and 'b'. Then these 2 linked lists 'a' and 'b' move to its next node. Then go to the next WHILE loop.

However, it's wrong. When I debug, in this first WHILE loop, when it finished this

cur.next = b;

it shows that variables will change as follow:

a: [1,5,4]
b: [5,4]
cur: [1,5,4]

I'm so confused why 'a' linked list will change to [1,5,4]? I think 'a' linked list won't change at this point, it keeps as [1,2,3].

--------But when I change WHILE loop as this following, it works:

    while(a != null && b != null){
            cur.next = a;
            a=a.next;
            cur = cur.next;
            cur.next = b;
            b=b.next;
            cur = cur.next;
        }

So my question is:
what's the difference between these two WHILE loop?

    while(a != null && b != null){
            cur.next = a;
            a=a.next;
            cur = cur.next;

            cur.next = b;
            b=b.next;
            cur = cur.next;
        }

while(a != null && b != null){
            cur.next = a;
            cur = cur.next;
     
            cur.next = b;
            cur = cur.next;
            
            b=b.next;
            a=a.next;
        }

The problem that when cur points to a node whose next is still needed you still cannot assign to next.

Tip at the end of a method return; is not needed.

It may help to first use recursion, doing an easy bit of work, and call other instances of the same method for the rest.

A recursion would be:

private ListNode merge(ListNode a, ListNode b) {
    if (a == null) {
        return b;
    } else if (b == null) {
        return a;
    }
    ListNode anext = a.next;
    a.next = merge(b, a.next);
    return a;
}

which becomes iterative:

private ListNode merge(ListNode a, ListNode b) {
    while (true) {
        if (a == null) {
            return b;
        } else if (b == null) {
            return a;
        }
        ListNode anext = a.next;
        a.next = b;

        a = b;
        b = anext;
    }
}

This handles lists with different lengths, and hence needs a result.

The difficult point is that instead of taking two steps a.next and b.next the call's arguments are switched.

Your version puts the results in a and requires that both lists have the same length.
a being null and b not so would not be possible.

In your first version a 0 element is first introduced.

Yes there is a bug in your while loop . For a correct merge algorithm your loop invariant should be at the end of each iteration in the while loop ListNode a and b should point to next element in their respective list .

while(a != null && b != null){
            cur.next = a;
            cur = cur.next;
     
            cur.next = b;
            cur = cur.next;
            
            b=b.next; 
            a=a.next; // you are making a point to node in list b , which is wrong .
        }

From your test data

List a : 1 -> 2 -3
List b : 4 -> 5

Lets check the invariant of your while loop after 1st iteration

(i) a=a.next sets a to first node in b i.e 4 whilst it should point to next element in its own list 1->2->3 i.e 2

This breaks your algorithm.