Merge Two Sorted Linked Lists
1. You are given a partially written LinkedList class.Input Format
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 is managed for youOutput Format
Output is managed for youQuestion Video
1. O(n) time complexity and constant space complexity expected.Sample Input
5Sample Output
10 20 30 40 50
10
7 9 12 15 37 43 44 48 52 56
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 nonempty list is taken care of by adding it at the end of the resultant list.
For the implementation, we are using an inbuilt LinkedList class for creating lists, and for performing operations on the list we are using the class inbuilt functions.
Below is the implementation in Java:
public static LinkedList mergeTwoSortedLists(LinkedList l1, LinkedList l2) { LinkedList ml = new LinkedList(); Node one = l1.head; Node two = l2.head; while (one != null && two != null) { if (one.data < two.data) { ml.addLast(one.data); one = one.next; } else { ml.addLast(two.data); two = two.next; } } while (one != null) { ml.addLast(one.data); one = one.next; } while (two != null) { ml.addLast(two.data); 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.

Asked in Companies

Related Topics