# Merge Two Sorted Linked Lists #### Try First, Check Solution later

1. You should first read the question and watch the question video.
2. Think of a solution approach, then try and submit the question on editor tab.
3. We strongly advise you to watch the solution video for prescribed approach.

`1. You are given a partially written LinkedList class.2. You are required to complete the body of mergeTwoSortedLists function. The function is static and is passed two lists which are sorted. The function is expected to return a new sorted list containing elements of both lists. Original lists must stay as they were.3. Input and Output is managed for you.`
Input Format
`Input is managed for you`
Output Format
`Output is managed for you`
Question Video
Constraints
`1. O(n) time complexity and constant space complexity expected.`
Sample Input
`510 20 30 40 50107 9 12 15 37 43 44 48 52 56`
Sample Output
`7 9 10 12 15 20 30 37 40 43 44 48 50 52 56 10 20 30 40 50 7 9 12 15 37 43 44 48 52 56 `

• Editorial

The problem here deals with implementing the mergeTwoSortedLists() function which returns the sorted list by combining the two input lists.

In this problem, we are given two sorted linked lists and we wish to return the sorted combination of these lists. A point to note here is that if an element in list 1 is smaller than list 2 then it is obvious that it will be the smallest among all the remaining elements in both list 1 and list 2. Keeping this in mind, the approach that we are going to follow here is a simple one, wherein, we are keeping two pointers one for list 1 and the other for list 2 both initially at their respective head node. Now a comparison is made between their elements and the smaller one is selected and added to the resultant list and that pointer is updated. This process keeps on going until any one of the lists becomes empty. The other non-empty list is taken care of by adding it at the end of the resultant list.

For the implementation, we are using an in-built LinkedList class for creating lists, and for performing operations on the list we are using the class in-built functions.

Below is the implementation in Java:

```public static LinkedList mergeTwoSortedLists(LinkedList l1, LinkedList l2) {
while (one != null && two != null) {
if (one.data < two.data) {
one = one.next;
} else {
two = two.next;
}
}
while (one != null) {
one = one.next;
}
while (two != null) {
two = two.next;
}
return ml;
}```

java false

Dry Run

List 1: 30 -> 42 -> 46 -> 51 (List A)

List 2: 12 -> 40 -> 50 (List B)

Output List: 12 -> 30 -> 40 -> 42 -> 46 -> 50 -> 51

Initially, one = A1 node and two = B1 node

1. First Iteration

one.data ( = 30)>two.data ( = 12)

Output List: 12 ->null

one = A2 node and two = B2 node

2. Second Iteration

one.data ( = 30)

Output List: 12 ->30 ->null

one = A2 node and two = B2 node

3. Third Iteration

one.data ( = 42)>two.data (= 40)

Output List: 12 -> 30 -> 40 ->null

one = A2 node and two = B3 node

4. Fourth Iteration

one.data ( = 42)

Output List: 12 -> 30 ->40 -> 42 ->null

one = A3 node and two = B3 node

5. Fifth Iteration

one.data ( = 46)

Output List: 12 -> 30 -> 40 -> 42 -> 46 ->null

one = A4 node and two = B3 node

6. Sixth Iteration

one.data ( = 51)>two.data ( = 50)

Output List: 12 -> 30 -> 40 -> 42 -> 46 -> 50 ->null

one = A4 node and two = null

As one != null adding remaining list A elements,

Output List: 12 -> 30 -> 40 -> 42 -> 46 -> 50 ->51 ->null

Hence verified.

Time Complexity: O(n)

The time complexity for the function is linear as the traversal of both the lists are involved. Here we visit each and every element in both the lists which makes our algorithm linear. Here n denotes the combined length of both the lists.

Space Complexity: O(n)

The space complexity for the function is linear as we have created an output list with size proportional to the combined length of both lists.

• Related Topics

Run

Run
Id Name