**Merge two sorted linked lists**

### Problem Statement :

This challenge is part of a tutorial track by MyCodeSchool Given pointers to the heads of two sorted linked lists, merge them into a single, sorted linked list. Either head pointer may be null meaning that the corresponding list is empty. Example headA refers to 1 -> 3 -> 7 -> NULL headB refers to 1 -> 2 -> NULL The new list is 1 -> 1 -> 2 -> 3 -> 7 -> NULL. Function Description Complete the mergeLists function in the editor below. mergeLists has the following parameters: SinglyLinkedListNode pointer headA: a reference to the head of a list SinglyLinkedListNode pointer headB: a reference to the head of a list Returns SinglyLinkedListNode pointer: a reference to the head of the merged list Input Format The first line contains an integer t, the number of test cases. The format for each test case is as follows: The first line contains an integer n, the length of the first linked list. The next n lines contain an integer each, the elements of the linked list. The next line contains an integer m , the length of the second linked list. The next m lines contain an integer each, the elements of the second linked list.

### Solution :

` ````
Solution in C :
In C++ :
/*
Merge two sorted lists A and B as one linked list
Node is defined as
struct Node
{
int data;
struct Node *next;
}
*/
Node* MergeLists(Node *a, Node*b)
{
// This is a "method-only" submission.
// You only need to complete this method
Node* result = NULL;
/* Base cases */
if (a == NULL)
return(b);
else if (b==NULL)
return(a);
/* Pick either a or b, and recur */
if (a->data <= b->data)
{
result = a;
result->next = MergeLists(a->next, b);
}
else
{
result = b;
result->next = MergeLists(a, b->next);
}
return(result);
}
In C :
// Complete the mergeLists function below.
/*
* For your reference:
*
* SinglyLinkedListNode {
* int data;
* SinglyLinkedListNode* next;
* };
*
*/
SinglyLinkedListNode* mergeLists(SinglyLinkedListNode* head1, SinglyLinkedListNode* head2) {
SinglyLinkedList *newHead = malloc(sizeof(SinglyLinkedList));
newHead->head = NULL;
newHead->tail = NULL;
while(head1 != NULL && head2 != NULL){
if(head1->data > head2->data){
insert_node_into_singly_linked_list(&newHead, head2->data);
head2 = head2->next;
}
else if(head1->data < head2->data){
insert_node_into_singly_linked_list(&newHead, head1->data);
head1 = head1->next;
}
else{
insert_node_into_singly_linked_list(&newHead, head1->data);
insert_node_into_singly_linked_list(&newHead, head2->data);
head1 = head1->next;
head2 = head2->next;
}
}
while(head1 != NULL){
insert_node_into_singly_linked_list(&newHead, head1->data);
head1 = head1->next;
}
while(head2 != NULL){
insert_node_into_singly_linked_list(&newHead, head2->data);
head2 = head2->next;
}
return newHead->head;
}
In Java :
/*
Insert Node at the end of a linked list
head pointer input could be NULL as well for empty list
Node is defined as
class Node {
int data;
Node next;
}
*/
Node MergeLists(Node list1, Node list2) {
// This is a "method-only" submission.
// You only need to complete this method
Node dummy = new Node();
dummy.next=null;
dummy.data=0;
Node temp= dummy;
while(true)
{
if(list1==null)
{ temp.next = list2;
break;
}
else if(list2==null){
temp.next = list1;
break;
}
else if(list1.data < list2.data)
{
temp.next=list1;
list1=list1.next;
}
else{
temp.next=list2;
list2=list2.next;
}
temp=temp.next;
}
return dummy.next;
}
In python3 :
"""
Merge two linked lists
head could be None as well for empty list
Node is defined as
class Node(object):
def __init__(self, data=None, next_node=None):
self.data = data
self.next = next_node
return back the head of the linked list in the below method.
"""
def MergeLists(headA, headB):
if (headA==None) | (headB==None):
if(headA == None):
return headB
else:
return headA
if headA.data > headB.data: # headA points to the smaller one
temp = headA
headA = headB
headB = temp
head = headA
curA = headA.next # curA one step ahead
curB = headB
while (curA!=None) & (curB!=None):
if (curA.data>=curB.data):
headB =headB.next
curB.next = curA
headA.next = curB
headA = curA
curA = curA.next
curB = headB
else:
headA =curA
curA = curA.next
if curA == None:
headA.next = headB
return head
```

## View More Similar Problems

## Pair Sums

Given an array, we define its value to be the value obtained by following these instructions: Write down all pairs of numbers from this array. Compute the product of each pair. Find the sum of all the products. For example, for a given array, for a given array [7,2 ,-1 ,2 ] Note that ( 7 , 2 ) is listed twice, one for each occurrence of 2. Given an array of integers, find the largest v

View Solution →## Lazy White Falcon

White Falcon just solved the data structure problem below using heavy-light decomposition. Can you help her find a new solution that doesn't require implementing any fancy techniques? There are 2 types of query operations that can be performed on a tree: 1 u x: Assign x as the value of node u. 2 u v: Print the sum of the node values in the unique path from node u to node v. Given a tree wi

View Solution →## Ticket to Ride

Simon received the board game Ticket to Ride as a birthday present. After playing it with his friends, he decides to come up with a strategy for the game. There are n cities on the map and n - 1 road plans. Each road plan consists of the following: Two cities which can be directly connected by a road. The length of the proposed road. The entire road plan is designed in such a way that if o

View Solution →## Heavy Light White Falcon

Our lazy white falcon finally decided to learn heavy-light decomposition. Her teacher gave an assignment for her to practice this new technique. Please help her by solving this problem. You are given a tree with N nodes and each node's value is initially 0. The problem asks you to operate the following two types of queries: "1 u x" assign x to the value of the node . "2 u v" print the maxim

View Solution →## Number Game on a Tree

Andy and Lily love playing games with numbers and trees. Today they have a tree consisting of n nodes and n -1 edges. Each edge i has an integer weight, wi. Before the game starts, Andy chooses an unordered pair of distinct nodes, ( u , v ), and uses all the edge weights present on the unique path from node u to node v to construct a list of numbers. For example, in the diagram below, Andy

View Solution →## Heavy Light 2 White Falcon

White Falcon was amazed by what she can do with heavy-light decomposition on trees. As a resut, she wants to improve her expertise on heavy-light decomposition. Her teacher gave her an another assignment which requires path updates. As always, White Falcon needs your help with the assignment. You are given a tree with N nodes and each node's value Vi is initially 0. Let's denote the path fr

View Solution →