/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode() {}

 *     ListNode(int val) { this.val = val; }

 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }

 * }

 */

class Solution {

    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {

    }

}

a=[2,4,1,4]

b=[0,2,3,4]

a.extend(b)

a.sort()

print(a)

# Makes list1 longer by appending the elements of list2 at the end.

list1.extend(list2)

​

var mergeTwoLists = function(list1, list2) {

​

    // using dummy head to avoid writing additional code for edge cases (e.g. list = null).

    // using "new" keyword to create a new object. It makes the this variable point to the newly created object.

    // p is the pointer of dummy, p1 is the pointer of list1, p2 is the pointer of list2

    let dummy = new ListNode(0);

    let p = dummy;

    let p1 = list1;

    let p2 = list2;

​

    //   while both lists are not null.

    while (p1 && p2 ){

        // compare the number of nodes. insert the smaller node to the result

        if (p1.val > p2.val){

            p.next = p2;

            p2 = p2.next;

        }else{

            p.next = p1;

            p1 = p1.next;

        }

        // move the pointer to the next one

        p = p.next;

    }

    // if every node of one list has been traversaled, we will insert the rest of the other list to the result

    p.next = p1 || p2;

    return dummy.next;

};

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     public var val: Int

 *     public var next: ListNode?

 *     public init() { self.val = 0; self.next = nil; }

 *     public init(_ val: Int) { self.val = val; self.next = nil; }

 *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }

 * }

 */

class Solution {

    func mergeTwoLists(_ list1: ListNode?, _ list2: ListNode?) -> ListNode? {

    }

}

/**

 * Definition for singly-linked list.

 * struct ListNode {

 *     int val;

 *     ListNode *next;

 *     ListNode() : val(0), next(nullptr) {}

 *     ListNode(int x) : val(x), next(nullptr) {}

 *     ListNode(int x, ListNode *next) : val(x), next(next) {}

 * };

 */

class Solution {

public:

    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {

    }

};

/**

 * Definition for singly-linked list.

 * struct ListNode {

 *     int val;

 *     struct ListNode *next;

 * };

 */

​

​

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){

​

}

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     public int val;

 *     public ListNode next;

 *     public ListNode(int val=0, ListNode next=null) {

 *         this.val = val;

 *         this.next = next;

 *     }

 * }

 */

public class Solution {

    public ListNode MergeTwoLists(ListNode list1, ListNode list2) {

    }

}

/**

 * Definition for singly-linked list.

 * function ListNode(val, next) {

 *     this.val = (val===undefined ? 0 : val)

 *     this.next = (next===undefined ? null : next)

 * }

 */

/**

 * @param {ListNode} list1

 * @param {ListNode} list2

 * @return {ListNode}

 */

var mergeTwoLists = function(list1, list2) {

};

# Definition for singly-linked list.

# class ListNode

#     attr_accessor :val, :next

#     def initialize(val = 0, _next = nil)

#         @val = val

#         @next = _next

#     end

# end

# @param {ListNode} list1

# @param {ListNode} list2

# @return {ListNode}

def merge_two_lists(list1, list2)

end