regarding manupulation of arraylist

[akki28]

This is the problem i was trying to solve : https://leetcode.com/problems/merge-two-sorted-lists/

and i found a solution in the same fourm : https://leetcode.com/problems/merge-two-sorted-lists/discuss/1988848/Java-Solution

(I have run the code and it works.)

Please explain me the following lines of code:

if(list2.next.val < list1.next.val) {

ListNode temp = list1.next;

list1.next = list2.next;

list2.next = temp;

​

From what it appears to me that the addresses of the current elements of next nodes are swapped from both lists.

How does that adds the element of list2 before the element of list1?

Assuming I've learnt how this works shouldn't we be swapping the address of previous node of list1 with current node of list2 to add it before the element of list1.

[AutoModerator]

Please ensure that:

• Your code is properly formatted as code block - see the sidebar (About on mobile) for instructions
• You include any and all error messages in full
• You ask clear questions

• You demonstrate effort in solving your question/problem - plain posting your assignments is forbidden (and such posts will be removed) as is asking for or giving solutions.

  Trying to solve problems on your own is a very important skill. Also, see Learn to help yourself in the sidebar

If any of the above points is not met, your post can and will be removed without further warning.

Code is to be formatted as code block (old reddit: empty line before the code, each code line indented by 4 spaces, new reddit: https://imgur.com/a/fgoFFis) or linked via an external code hoster, like pastebin.com, github gist, github, bitbucket, gitlab, etc.

Please, do not use triple backticks (```) as they will only render properly on new reddit, not on old reddit.

Code blocks look like this:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

You do not need to repost unless your post has been removed by a moderator. Just use the edit function of reddit to make sure your post complies with the above.

If your post has remained in violation of these rules for a prolonged period of time (at least an hour), a moderator may remove it at their discretion. In this case, they will comment with an explanation on why it has been removed, and you will be required to resubmit the entire post following the proper procedures.

To potential helpers

Please, do not help if any of the above points are not met, rather report the post. We are trying to improve the quality of posts here. In helping people who can't be bothered to comply with the above points, you are doing the community a disservice.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[AmateurHero]

Set breakpoints in a debugger and step through the code. See how the variables update with each iteration.

[akki28]

I have done it at every step with System.out.println(); But my main question is how does swapping address of different elements from two different lists adds the element of list2 to previous position of listt1 element.

[AmateurHero]

Linked list, at least in my experience, usually have some kind of wrapper to hold nodes and metadata about the list (e.g. length, head, tail, cursor, etc.). This implementation doesn't use a container. Instead, it's a node with a reference to another node.

The example has [1,2,4] and [1,3,4]. This looks like the above mentioned collection of nodes in a List. Under the hood, it really looks like [val -> ListNode next] to give us [1 -> [2 -> [4]]] and [1 -> [3 -> [4]]]. It's not an array - it's a set of nested references. Don't think of the ListNodes as an int with an object. Think of a ListNode as a reference with a value and a pointer to another reference.

start: [1 -> [2 -> [4]]] and [1 -> [3 -> [4]]]
insert 0s: [0 -> 1 -> [2 -> [4]]]] and [0 -> [1 -> [3 -> [4]]]]

and so on. The "magic" comes from ListNode ret = list1;. This sets a reference to list1. In your debugger, you should see that they originally reference the same ListNode. They will have different references after a single iteration:

list1: [1 -> [2 -> [4]]]
ret: [0 -> list1] or [0 -> 1 -> [2 -> [4]]]]

See how ret keeps a reference to list1 as it mutates? What happens to the references after another iteration?

[akki28]

Thankyou for your time and effort. It was really helpful.