Construct a Maximum Sum Linked List out of two Sorted Linked Lists having some Common nodes
Given two sorted linked lists, construct a linked list that contains maximum sum path from start to end. The result list may contain nodes from both input lists. When constructing the result list, we may switch to the other input list only at the point of intersection (which mean the two node with the same value in the lists). You are allowed to use O(1) extra space.
Input:
List1 = 1->3->30->90->120->240->511
List2 = 0->3->12->32->90->125->240->249
Output: Following is maximum sum linked list out of two input lists
list = 1->3->12->32->90->125->240->511
we switch at 3 and 240 to get above maximum sum linked list
We strongly recommend to minimize the browser and try this yourself first.
The idea here in the below solution is to adjust next pointers after common nodes.
- Start with head of both linked lists and find first common node. Use merging technique of sorted linked list for that.
- Keep track of sum of the elements too while doing this and set head of result list based on greater sum till first common node.
- After this till the current pointers of both lists don’t become NULL we need to adjust the next of prev pointers based on greater sum.
This way it can be done in-place with constant extra space.
Time complexity of the below solution is O(n).
Implementation:
C++
#include<bits/stdc++.h>
using namespace std;
struct Node
{
int data;
Node *next;
};
void push(Node **head, int data)
{
Node *newnode = new Node;
newnode->data = data;
newnode->next = *head;
*head = newnode;
}
void finalMaxSumList(Node *a, Node *b)
{
Node *result = NULL;
Node *pre1 = a, *curr1 = a;
Node *pre2 = b, *curr2 = b;
while (curr1 != NULL || curr2 != NULL)
{
int sum1 = 0, sum2 = 0;
while (curr1!=NULL && curr2!=NULL && curr1->data!=curr2->data)
{
if (curr1->data < curr2->data)
{
sum1 += curr1->data;
curr1 = curr1->next;
}
else
{
sum2 += curr2->data;
curr2 = curr2->next;
}
}
if (curr1 == NULL)
{
while (curr2 != NULL)
{
sum2 += curr2->data;
curr2 = curr2->next;
}
}
if (curr2 == NULL)
{
while (curr1 != NULL)
{
sum1 += curr1->data;
curr1 = curr1->next;
}
}
if (pre1 == a && pre2 == b)
result = (sum1 > sum2)? pre1 : pre2;
else
{
if (sum1 > sum2)
pre2->next = pre1->next;
else
pre1->next = pre2->next;
}
pre1 = curr1, pre2 = curr2;
if (curr1)
curr1 = curr1->next;
if (curr2)
curr2 = curr2->next;
}
while (result != NULL)
{
cout << result->data << " " ;
result = result->next;
}
}
int main()
{
Node *head1 = NULL, *head2 = NULL;
push(&head1, 120);
push(&head1, 110);
push(&head1, 90);
push(&head1, 30);
push(&head1, 3);
push(&head1, 1);
push(&head2, 130);
push(&head2, 120);
push(&head2, 100);
push(&head2, 90);
push(&head2, 32);
push(&head2, 12);
push(&head2, 3);
push(&head2, 0);
finalMaxSumList(head1, head2);
return 0;
}
|
Java
class LinkedList
{
Node head;
class Node
{
int data;
Node next;
Node( int d)
{
data = d;
next = null ;
}
}
void finalMaxSumList(Node a, Node b)
{
Node result = null ;
Node pre1 = a, curr1 = a;
Node pre2 = b, curr2 = b;
while (curr1 != null || curr2 != null )
{
int sum1 = 0 , sum2 = 0 ;
while (curr1 != null && curr2 != null &&
curr1.data != curr2.data)
{
if (curr1.data<curr2.data)
{
sum1 += curr1.data;
curr1 = curr1.next;
}
else
{
sum2 += curr2.data;
curr2 = curr2.next;
}
}
if (curr1 == null )
{
while (curr2 != null )
{
sum2 += curr2.data;
curr2 = curr2.next;
}
}
if (curr2 == null )
{
while (curr1 != null )
{
sum1 += curr1.data;
curr1 = curr1.next;
}
}
if (pre1 == a && pre2 == b)
result = (sum1 > sum2) ? pre1 : pre2;
else
{
if (sum1 > sum2)
pre2.next = pre1.next;
else
pre1.next = pre2.next;
}
pre1 = curr1;
pre2 = curr2;
if (curr1 != null )
curr1 = curr1.next;
if (curr2 != null )
curr2 = curr2.next;
}
while (result != null )
{
System.out.print(result.data + " " );
result = result.next;
}
System.out.println();
}
void push( int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
public static void main(String args[])
{
LinkedList llist1 = new LinkedList();
LinkedList llist2 = new LinkedList();
llist1.push( 120 );
llist1.push( 110 );
llist1.push( 90 );
llist1.push( 30 );
llist1.push( 3 );
llist1.push( 1 );
llist2.push( 130 );
llist2.push( 120 );
llist2.push( 100 );
llist2.push( 90 );
llist2.push( 32 );
llist2.push( 12 );
llist2.push( 3 );
llist2.push( 0 );
llist1.finalMaxSumList(llist1.head, llist2.head);
}
}
|
Python3
class LinkedList( object ):
def __init__( self ):
self .head = None
class Node( object ):
def __init__( self , d):
self .data = d
self . next = None
def finalMaxSumList( self , a, b):
result = None
pre1 = a
curr1 = a
pre2 = b
curr2 = b
while curr1 ! = None or curr2 ! = None :
sum1 = 0
sum2 = 0
while curr1 ! = None and curr2 ! = None and curr1.data ! = curr2.data:
if curr1.data < curr2.data:
sum1 + = curr1.data
curr1 = curr1. next
else :
sum2 + = curr2.data
curr2 = curr2. next
if curr1 = = None :
while curr2 ! = None :
sum2 + = curr2.data
curr2 = curr2. next
if curr2 = = None :
while curr1 ! = None :
sum1 + = curr1.data
curr1 = curr1. next
if pre1 = = a and pre2 = = b:
result = pre1 if (sum1 > sum2) else pre2
else :
if sum1 > sum2:
pre2. next = pre1. next
else :
pre1. next = pre2. next
pre1 = curr1
pre2 = curr2
if curr1 ! = None :
curr1 = curr1. next
if curr2 ! = None :
curr2 = curr2. next
while result ! = None :
print ( str (result.data),end = " " )
result = result. next
print ()
def push( self , new_data):
new_node = self .Node(new_data)
new_node. next = self .head
self .head = new_node
llist1 = LinkedList()
llist2 = LinkedList()
llist1.push( 120 )
llist1.push( 110 )
llist1.push( 90 )
llist1.push( 30 )
llist1.push( 3 )
llist1.push( 1 )
llist2.push( 130 )
llist2.push( 120 )
llist2.push( 100 )
llist2.push( 90 )
llist2.push( 32 )
llist2.push( 12 )
llist2.push( 3 )
llist2.push( 0 )
llist1.finalMaxSumList(llist1.head, llist2.head)
|
C#
using System;
public class LinkedList
{
Node head;
public class Node
{
public int data;
public Node next;
public Node( int d)
{
data = d;
next = null ;
}
}
void finalMaxSumList(Node a, Node b)
{
Node result = null ;
Node pre1 = a, curr1 = a;
Node pre2 = b, curr2 = b;
while (curr1 != null || curr2 != null )
{
int sum1 = 0, sum2 = 0;
while (curr1 != null && curr2 != null &&
curr1.data != curr2.data)
{
if (curr1.data<curr2.data)
{
sum1 += curr1.data;
curr1 = curr1.next;
}
else
{
sum2 += curr2.data;
curr2 = curr2.next;
}
}
if (curr1 == null )
{
while (curr2 != null )
{
sum2 += curr2.data;
curr2 = curr2.next;
}
}
if (curr2 == null )
{
while (curr1 != null )
{
sum1 += curr1.data;
curr1 = curr1.next;
}
}
if (pre1 == a && pre2 == b)
result = (sum1 > sum2) ? pre1 : pre2;
else
{
if (sum1 > sum2)
pre2.next = pre1.next;
else
pre1.next = pre2.next;
}
pre1 = curr1;
pre2 = curr2;
if (curr1 != null )
curr1 = curr1.next;
if (curr2 != null )
curr2 = curr2.next;
}
while (result != null )
{
Console.Write(result.data + " " );
result = result.next;
}
Console.WriteLine();
}
void push( int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
public static void Main()
{
LinkedList llist1 = new LinkedList();
LinkedList llist2 = new LinkedList();
llist1.push(120);
llist1.push(110);
llist1.push(90);
llist1.push(30);
llist1.push(3);
llist1.push(1);
llist2.push(130);
llist2.push(120);
llist2.push(100);
llist2.push(90);
llist2.push(32);
llist2.push(12);
llist2.push(3);
llist2.push(0);
llist1.finalMaxSumList(llist1.head, llist2.head);
}
}
|
Javascript
<script>
var head;
class Node {
constructor(val) {
this .data = val;
this .next = null ;
}
}
function finalMaxSumList(a, b) {
var result = null ;
var pre1 = a, curr1 = a;
var pre2 = b, curr2 = b;
while (curr1 != null || curr2 != null )
{
var sum1 = 0, sum2 = 0;
while (curr1 != null && curr2 != null && curr1.data != curr2.data) {
if (curr1.data < curr2.data) {
sum1 += curr1.data;
curr1 = curr1.next;
} else {
sum2 += curr2.data;
curr2 = curr2.next;
}
}
if (curr1 == null ) {
while (curr2 != null ) {
sum2 += curr2.data;
curr2 = curr2.next;
}
}
if (curr2 == null ) {
while (curr1 != null ) {
sum1 += curr1.data;
curr1 = curr1.next;
}
}
if (pre1 == a && pre2 == b)
result = (sum1 > sum2) ? pre1 : pre2;
else {
if (sum1 > sum2)
pre2.next = pre1.next;
else
pre1.next = pre2.next;
}
pre1 = curr1;
pre2 = curr2;
if (curr1 != null )
curr1 = curr1.next;
if (curr2 != null )
curr2 = curr2.next;
}
while (result != null ) {
document.write(result.data + " " );
result = result.next;
}
document.write();
}
function push(headl, new_data) {
var new_node = new Node(new_data);
new_node.next = headl;
headl = new_node;
return headl;
}
var llist1 = null ; var llist2 = null ;
llist1 = push(llist1,120);
llist1=push(llist1,110);
llist1=push(llist1,90);
llist1=push(llist1,30);
llist1=push(llist1,3);
llist1=push(llist1,1);
llist2=push(llist2,130);
llist2=push(llist2,120);
llist2=push(llist2,100);
llist2=push(llist2,90);
llist2=push(llist2,32);
llist2=push(llist2,12);
llist2=push(llist2,3);
llist2=push(llist2,0);
finalMaxSumList(llist1, llist2);
</script>
|
Output
1 3 12 32 90 110 120 130
Time complexity: O(n) where n is the length of bigger linked list
Auxiliary space: O(1)
However a problem in this solution is that the original lists are changed.
Exercise:
1. Try this problem when auxiliary space is not a constraint.
2. Try this problem when we don’t modify the actual list and create the resultant list.
Last Updated :
24 Jun, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...