Multiply two numbers represented by Linked Lists
Last Updated :
15 Sep, 2023
Given two numbers represented by linked lists, write a function that returns the multiplication of these two linked lists.
Examples:
Input : 9->4->6
8->4
Output : 79464
Input : 3->2->1
1->2
Output : 3852
Solution:
Traverse both lists and generate the required numbers to be multiplied and then return the multiplied values of the two numbers.
Algorithm to generate the number from linked list representation:
1) Initialize a variable to zero
2) Start traversing the linked list
3) Add the value of first node to this variable
4) From the second node, multiply the variable by 10
and also take modulus of this value by 10^9+7
and then add the value of the node to this
variable.
5) Repeat step 4 until we reach the last node of the list.
Use the above algorithm with both of linked lists to generate the numbers.
Below is the program for multiplying two numbers represented as linked lists:
C++
#include<bits/stdc++.h>
#include<stdio.h>
using namespace std;
struct Node
{
int data;
struct Node* next;
};
struct Node *newNode( int data)
{
struct Node *new_node = ( struct Node *) malloc ( sizeof ( struct Node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}
void push( struct Node** head_ref, int new_data)
{
struct Node* new_node = newNode(new_data);
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
long long multiplyTwoLists (Node* first, Node* second)
{
long long N= 1000000007;
long long num1 = 0, num2 = 0;
while (first || second){
if (first){
num1 = ((num1)*10)%N + first->data;
first = first->next;
}
if (second)
{
num2 = ((num2)*10)%N + second->data;
second = second->next;
}
}
return ((num1%N)*(num2%N))%N;
}
void printList( struct Node *node)
{
while (node != NULL)
{
cout<<node->data;
if (node->next)
cout<< "->" ;
node = node->next;
}
cout<< "\n" ;
}
int main()
{
struct Node* first = NULL;
struct Node* second = NULL;
push(&first, 6);
push(&first, 4);
push(&first, 9);
printf ( "First List is: " );
printList(first);
push(&second, 4);
push(&second, 8);
printf ( "Second List is: " );
printList(second);
cout<< "Result is: " ;
cout<<multiplyTwoLists(first, second);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data;
struct Node* next;
} Node;
struct Node* newNode( int data)
{
Node* new_node = (Node*) malloc ( sizeof (Node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}
void push( struct Node** head_ref, int new_data)
{
struct Node* new_node = newNode(new_data);
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
long long multiplyTwoLists(Node* first, Node* second)
{
long long N = 1000000007;
long long num1 = 0, num2 = 0;
while (first || second) {
if (first) {
num1 = ((num1)*10) % N + first->data;
first = first->next;
}
if (second) {
num2 = ((num2)*10) % N + second->data;
second = second->next;
}
}
return ((num1 % N) * (num2 % N)) % N;
}
void printList( struct Node* node)
{
while (node != NULL) {
printf ( "%d" , node->data);
if (node->next)
printf ( "->" );
node = node->next;
}
printf ( "\n" );
}
int main()
{
struct Node* first = NULL;
struct Node* second = NULL;
push(&first, 6);
push(&first, 4);
push(&first, 9);
printf ( "First List is: " );
printList(first);
push(&second, 4);
push(&second, 8);
printf ( "Second List is: " );
printList(second);
printf ( "Result is: " );
printf ( "%lld" , multiplyTwoLists(first, second));
return 0;
}
|
Java
import java.util.*;
public class GFG{
static class Node
{
int data;
Node next;
Node( int data){
this .data = data;
next = null ;
}
}
static long multiplyTwoLists(Node first, Node second)
{
long N = 1000000007 ;
long num1 = 0 , num2 = 0 ;
while (first != null || second != null ){
if (first != null ){
num1 = ((num1)* 10 )%N + first.data;
first = first.next;
}
if (second != null )
{
num2 = ((num2)* 10 )%N + second.data;
second = second.next;
}
}
return ((num1%N)*(num2%N))%N;
}
static void printList(Node node)
{
while (node != null )
{
System.out.print(node.data);
if (node.next != null )
System.out.print( "->" );
node = node.next;
}
System.out.println();
}
public static void main(String args[])
{
Node first = new Node( 9 );
first.next = new Node( 4 );
first.next.next = new Node( 6 );
System.out.print( "First List is: " );
printList(first);
Node second = new Node( 8 );
second.next = new Node( 4 );
System.out.print( "Second List is: " );
printList(second);
System.out.print( "Result is: " );
System.out.println(multiplyTwoLists(first, second));
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self . next = None
class LinkedList:
def __init__( self ):
self .head = None
def push( self , new_data):
new_node = Node(new_data)
new_node. next = self .head
self .head = new_node
def printList( self ):
ptr = self .head
while (ptr ! = None ):
print (ptr.data, end = '')
if ptr. next ! = None :
print ( '->' , end = '')
ptr = ptr. next
print ()
def multiplyTwoLists(first, second):
num1 = 0
num2 = 0
first_ptr = first.head
second_ptr = second.head
while first_ptr ! = None or second_ptr ! = None :
if first_ptr ! = None :
num1 = (num1 * 10 ) + first_ptr.data
first_ptr = first_ptr. next
if second_ptr ! = None :
num2 = (num2 * 10 ) + second_ptr.data
second_ptr = second_ptr. next
return num1 * num2
if __name__ = = '__main__' :
first = LinkedList()
second = LinkedList()
first.push( 6 )
first.push( 4 )
first.push( 9 )
print ( "First list is: " , end = '')
first.printList()
second.push( 4 )
second.push( 8 )
print ( "Second List is: " , end = '')
second.printList()
result = multiplyTwoLists(first, second)
print ( "Result is: " , result)
|
C#
using System;
public class GFG
{
public class Node {
public int data;
public Node next;
public Node( int data)
{
this .data = data;
this .next = null ;
}
}
public static long multiplyTwoLists(Node first,
Node second)
{
var N = 1000000007;
var num1 = 0;
var num2 = 0;
while (first != null || second != null ) {
if (first != null ) {
num1 = ((num1)*10) % N + first.data;
first = first.next;
}
if (second != null ) {
num2 = ((num2)*10) % N + second.data;
second = second.next;
}
}
return ((num1 % N) * (num2 % N)) % N;
}
public static void printList(Node node)
{
while (node != null ) {
Console.Write(node.data);
if (node.next != null ) {
Console.Write( "->" );
}
node = node.next;
}
Console.WriteLine();
}
public static void Main(String[] args)
{
var first = new Node(9);
first.next = new Node(4);
first.next.next = new Node(6);
Console.Write( "First List is: " );
GFG.printList(first);
var second = new Node(8);
second.next = new Node(4);
Console.Write( "Second List is: " );
GFG.printList(second);
Console.Write( "Result is: " );
Console.WriteLine(
GFG.multiplyTwoLists(first, second));
}
}
|
Javascript
<script>
class Node
{
constructor(data)
{
this .data=data;
this .next = null ;
}
}
function multiplyTwoLists(first,second)
{
let N = 1000000007;
let num1 = 0, num2 = 0;
while (first != null || second != null ){
if (first != null ){
num1 = ((num1)*10)%N + first.data;
first = first.next;
}
if (second != null )
{
num2 = ((num2)*10)%N + second.data;
second = second.next;
}
}
return ((num1%N)*(num2%N))%N;
}
function printList(node)
{
while (node != null )
{
document.write(node.data);
if (node.next != null )
document.write( "->" );
node = node.next;
}
document.write( "<br>" );
}
let first = new Node(9);
first.next = new Node(4);
first.next.next = new Node(6);
document.write( "First List is: " );
printList(first);
let second = new Node(8);
second.next = new Node(4);
document.write( "Second List is: " );
printList(second);
document.write( "Result is: " );
document.write(multiplyTwoLists(first, second)+ "<br>" );
</script>
|
Output
First List is: 9->4->6
Second List is: 8->4
Result is: 79464
Time Complexity: O(max(n1, n2)), where n1 and n2 represents the number of nodes present in the first and second linked list respectively.
Auxiliary Space: O(1), no extra space is required, so it is a constant.
Share your thoughts in the comments
Please Login to comment...