Create a linked list from two linked lists by choosing max element at each position
Given two linked list of equal sizes, the task is to create new linked list using those linked lists where at every step, the maximum of the two elements from both the linked lists is chosen and the other is skipped.
Examples:
Input:
list1 = 5 -> 2 -> 3 -> 8 -> NULL
list2 = 1 -> 7 -> 4 -> 5 -> NULL
Output: 5 -> 7 -> 4 -> 8 -> NULL
Input:
list1 = 2 -> 8 -> 9 -> 3 -> NULL
list2 = 5 -> 3 -> 6 -> 4 -> NULL
Output: 5 -> 8 -> 9 -> 4 -> NULL
A linked list is a data structure where each element is connected to the next element in the list. In this task, we have two linked lists and we want to create a new linked list by picking the maximum element from each position of the two original linked lists and placing it in the same position in the new linked list.
For example, let’s say we have two linked lists:
List 1: [1, 3, 5, 7]
List 2: [2, 4, 6, 8]
To create the new linked list, we compare the first elements of both original linked lists, which are 1 and 2. We pick the maximum of these two, which is 2, and place it in the first position of the new linked list.
Next, we compare the second elements of both original linked lists, which are 3 and 4. We pick the maximum of these two, which is 4, and place it in the second position of the new linked list.
We repeat this process for all elements in both linked lists, until we have gone through all elements in both linked lists.
So, the new linked list would be: [2, 4, 6, 8]
This is how we can create a new linked list by choosing the maximum element at each position from two linked lists.
Approach: We traverse both the linked list at the same time and compare node from both the lists. The node which is greater among them, will be added to the new linked list. We do this for each node and then print the nodes of the generated linked list.
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
struct Node {
int data;
Node* next;
};
void insert(Node** root, int item)
{
Node *ptr, *temp;
temp = new Node;
temp->data = item;
temp->next = NULL;
if (*root == NULL)
*root = temp;
else {
ptr = *root;
while (ptr->next != NULL)
ptr = ptr->next;
ptr->next = temp;
}
}
void display(Node* root)
{
while (root != NULL) {
cout << root->data << " -> " ;
root = root->next;
}
cout << "NULL" ;
}
Node* newList(Node* root1, Node* root2)
{
Node *ptr1 = root1, *ptr2 = root2;
Node* root = NULL;
while (ptr1 != NULL) {
int currMax = ((ptr1->data < ptr2->data)
? ptr2->data
: ptr1->data);
if (root == NULL) {
Node* temp = new Node;
temp->data = currMax;
temp->next = NULL;
root = temp;
}
else {
insert(&root, currMax);
}
ptr1 = ptr1->next;
ptr2 = ptr2->next;
}
return root;
}
int main()
{
Node *root1 = NULL, *root2 = NULL, *root = NULL;
insert(&root1, 5);
insert(&root1, 2);
insert(&root1, 3);
insert(&root1, 8);
insert(&root2, 1);
insert(&root2, 7);
insert(&root2, 4);
insert(&root2, 5);
root = newList(root1, root2);
display(root);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static class Node
{
int data;
Node next;
};
static Node insert(Node root, int item)
{
Node ptr, temp;
temp = new Node();
temp.data = item;
temp.next = null ;
if (root == null )
root = temp;
else
{
ptr = root;
while (ptr.next != null )
ptr = ptr.next;
ptr.next = temp;
}
return root;
}
static void display(Node root)
{
while (root != null )
{
System.out.print( root.data + " - > " );
root = root.next;
}
System.out.print( "null" );
}
static Node newList(Node root1, Node root2)
{
Node ptr1 = root1, ptr2 = root2;
Node root = null ;
while (ptr1 != null )
{
int currMax = ((ptr1.data < ptr2.data)
? ptr2.data
: ptr1.data);
if (root == null )
{
Node temp = new Node();
temp.data = currMax;
temp.next = null ;
root = temp;
}
else
{
root = insert(root, currMax);
}
ptr1 = ptr1.next;
ptr2 = ptr2.next;
}
return root;
}
public static void main(String args[])
{
Node root1 = null , root2 = null , root = null ;
root1 = insert(root1, 5 );
root1 = insert(root1, 2 );
root1 = insert(root1, 3 );
root1 = insert(root1, 8 );
root2 = insert(root2, 1 );
root2 = insert(root2, 7 );
root2 = insert(root2, 4 );
root2 = insert(root2, 5 );
root = newList(root1, root2);
display(root);
}
}
|
Python3
import math
class Node:
def __init__( self , data):
self .data = data
self . next = None
def insert(root, item):
temp = Node(item)
temp.data = item
temp. next = None
if (root = = None ):
root = temp
else :
ptr = root
while (ptr. next ! = None ):
ptr = ptr. next
ptr. next = temp
return root
def display(root):
while (root ! = None ) :
print (root.data, end = "->" )
root = root. next
print ( "NULL" )
def newList(root1, root2):
ptr1 = root1
ptr2 = root2
root = None
while (ptr1 ! = None ) :
currMax = ((ptr1.data < ptr2.data) and
ptr2.data or ptr1.data)
if (root = = None ):
temp = Node(currMax)
temp.data = currMax
temp. next = None
root = temp
else :
root = insert(root, currMax)
ptr1 = ptr1. next
ptr2 = ptr2. next
return root
if __name__ = = '__main__' :
root1 = None
root2 = None
root = None
root1 = insert(root1, 5 )
root1 = insert(root1, 2 )
root1 = insert(root1, 3 )
root1 = insert(root1, 8 )
root2 = insert(root2, 1 )
root2 = insert(root2, 7 )
root2 = insert(root2, 4 )
root2 = insert(root2, 5 )
root = newList(root1, root2)
display(root)
|
C#
using System;
class GFG
{
public class Node
{
public int data;
public Node next;
};
static Node insert(Node root, int item)
{
Node ptr, temp;
temp = new Node();
temp.data = item;
temp.next = null ;
if (root == null )
root = temp;
else
{
ptr = root;
while (ptr.next != null )
ptr = ptr.next;
ptr.next = temp;
}
return root;
}
static void display(Node root)
{
while (root != null )
{
Console.Write( root.data + " - > " );
root = root.next;
}
Console.Write( "null" );
}
static Node newList(Node root1, Node root2)
{
Node ptr1 = root1, ptr2 = root2;
Node root = null ;
while (ptr1 != null )
{
int currMax = ((ptr1.data < ptr2.data)
? ptr2.data
: ptr1.data);
if (root == null )
{
Node temp = new Node();
temp.data = currMax;
temp.next = null ;
root = temp;
}
else
{
root = insert(root, currMax);
}
ptr1 = ptr1.next;
ptr2 = ptr2.next;
}
return root;
}
public static void Main(String []args)
{
Node root1 = null , root2 = null , root = null ;
root1 = insert(root1, 5);
root1 = insert(root1, 2);
root1 = insert(root1, 3);
root1 = insert(root1, 8);
root2 = insert(root2, 1);
root2 = insert(root2, 7);
root2 = insert(root2, 4);
root2 = insert(root2, 5);
root = newList(root1, root2);
display(root);
}
}
|
Javascript
<script>
class Node {
constructor() {
this .data = 0;
this .next = null ;
}
}
function insert( root , item)
{
var ptr, temp;
temp = new Node();
temp.data = item;
temp.next = null ;
if (root == null )
root = temp;
else {
ptr = root;
while (ptr.next != null )
ptr = ptr.next;
ptr.next = temp;
}
return root;
}
function display( root)
{
while (root != null )
{
document.write(root.data + " - > " );
root = root.next;
}
document.write( "null" );
}
function newList( root1, root2) {
ptr1 = root1, ptr2 = root2;
root = null ;
while (ptr1 != null ) {
var currMax = ((ptr1.data < ptr2.data) ? ptr2.data : ptr1.data);
if (root == null ) {
temp = new Node();
temp.data = currMax;
temp.next = null ;
root = temp;
}
else {
root = insert(root, currMax);
}
ptr1 = ptr1.next;
ptr2 = ptr2.next;
}
return root;
}
root1 = null , root2 = null , root = null ;
root1 = insert(root1, 5);
root1 = insert(root1, 2);
root1 = insert(root1, 3);
root1 = insert(root1, 8);
root2 = insert(root2, 1);
root2 = insert(root2, 7);
root2 = insert(root2, 4);
root2 = insert(root2, 5);
root = newList(root1, root2);
display(root);
</script>
|
Output:
5 -> 7 -> 4 -> 8 -> NULL
Time complexity: O(n) where n is size of linked list
Space complexity: O(n) where n is size of newly created linked list
Last Updated :
05 Feb, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...