Multiply two numbers represented as linked lists into a third list

Given two numbers represented by linked lists, write a function that returns the head of the new linked list that represents the number that is the product of those numbers.

Examples: 

Input : 9->4->6
        8->4
Output : 7->9->4->6->4

Input : 9->9->9->4->6->9
        9->9->8->4->9
Output : 9->9->7->9->5->9->8->0->1->8->1
 

We have already discussed a solution in below post. 
Multiply two numbers represented by Linked Lists

The solution discussed above stores result in an integer. Here we store result in a third list so that large numbers can be handled.
Remember old school multiplication? we imitate that process. On paper, we take the last digit of a number and multiply with the second number and write the product. Now leave the last column and same way each digit of one number is multiplied with every digit of other number and every time result is written by leaving one last column. then add these columns that forms the number. Now assume these columns as nodes of the resultant linked list. We make resultant linked list in reversed fashion. 

Algorithm:

Reverse both linked lists
Make a linked list of maximum result size (m + n + 1)
For each node of one list
  For each node of second list
   a) Multiply nodes
   b) Add digit in result LL at corresponding 
      position
   c) Now resultant node itself can be higher
      than one digit
   d) Make carry for next node
  Leave one last column means next time start
From next node in result list
Reverse the resulted linked list

Implementation:

C++

// C++ program to Multiply two numbers
// represented as linked lists
#include <bits/stdc++.h>
using namespace std;

// Linked list Node
struct Node {
    int data;
    struct Node* next;
};

// Function to create a new Node
// with given data
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;
}

// Function to insert a Node at the
// beginning of the Linked List
void push(struct Node** head_ref, int new_data)
{
    // allocate Node
    struct Node* new_node = newNode(new_data);

    // link the old list of the new Node
    new_node->next = (*head_ref);

    // move the head to point to the new Node
    (*head_ref) = new_node;
}

// Function to reverse the linked list and return
// its length
int reverse(struct Node** head_ref)
{
    struct Node* prev = NULL;
    struct Node* current = *head_ref;
    struct Node* next;
    int len = 0;
    while (current != NULL) {
        len++;
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    *head_ref = prev;
    return len;
}

// Function to make an empty linked list of
// given size
struct Node* make_empty_list(int size)
{
    struct Node* head = NULL;
    while (size--)
        push(&head, 0);
    return head;
}

// Multiply contents of two linked lists => store
// in another list and return its head
struct Node* multiplyTwoLists(struct Node* first,
                        struct Node* second)
{
    // reverse the lists to multiply from end
    // m and n lengths of linked lists to make
    // and empty list
    int m = reverse(&first), n = reverse(&second);

    // make a list that will contain the result
    // of multiplication.
    // m+n+1 can be max size of the list
    struct Node* result = make_empty_list(m + n + 1);

    // pointers for traverse linked lists and also
    // to reverse them after
    struct Node *second_ptr = second,
        *result_ptr1 = result, *result_ptr2, *first_ptr;

    // multiply each Node of second list with first
    while (second_ptr) {

        int carry = 0;

        // each time we start from the next of Node
        // from which we started last time
        result_ptr2 = result_ptr1;

        first_ptr = first;

        while (first_ptr) {

            // multiply a first list's digit with a
            // current second list's digit
            int mul = first_ptr->data * second_ptr->data
                    + carry;

            // Assign the product to corresponding Node
            // of result
            result_ptr2->data += mul % 10;

            // now resultant Node itself can have more
            // than 1 digit
            carry = mul / 10 + result_ptr2->data / 10;
            result_ptr2->data = result_ptr2->data % 10;

            first_ptr = first_ptr->next;
            result_ptr2 = result_ptr2->next;
        }

        // if carry is remaining from last multiplication
        if (carry > 0) {
            result_ptr2->data += carry;
        }

        result_ptr1 = result_ptr1->next;
        second_ptr = second_ptr->next;
    }

    // reverse the result_list as it was populated
    // from last Node
    reverse(&result);
    reverse(&first);
    reverse(&second);

    // remove if there are zeros at starting
    while (result->data == 0) {
        struct Node* temp = result;
        result = result->next;
        free(temp);
    }

    // Return head of multiplication list
    return result;
}

// A utility function to print a linked list
void printList(struct Node* Node)
{
    while (Node != NULL) {
        cout << Node->data;
        if (Node->next)
            cout<<"->";
        Node = Node->next;
    }
    cout << endl;
}

// Driver program to test above function
int main(void)
{
    struct Node* first = NULL;
    struct Node* second = NULL;

    // create first list 9->9->9->4->6->9
    push(&first, 9);
    push(&first, 6);
    push(&first, 4);
    push(&first, 9);
    push(&first, 9);
    push(&first, 9);
    cout<<"First List is: ";
    printList(first);

    // create second list 9->9->8->4->9
    push(&second, 9);
    push(&second, 4);
    push(&second, 8);
    push(&second, 9);
    push(&second, 9);
    cout<<"Second List is: ";
    printList(second);

    // Multiply the two lists and see result
    struct Node* result = multiplyTwoLists(first, second);
    cout << "Resultant list is: ";
    printList(result);

    return 0;
}

// This code is contributed by SHUBHAMSINGH10

C

// C program to Multiply two numbers
// represented as linked lists
#include <stdio.h>
#include <stdlib.h>

// Linked list Node
struct Node {
    int data;
    struct Node* next;
};

// Function to create a new Node
// with given data
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;
}

// Function to insert a Node at the
// beginning of the Linked List
void push(struct Node** head_ref, int new_data)
{
    // allocate Node
    struct Node* new_node = newNode(new_data);

    // link the old list of the new Node
    new_node->next = (*head_ref);

    // move the head to point to the new Node
    (*head_ref) = new_node;
}

// Function to reverse the linked list and return
// its length
int reverse(struct Node** head_ref)
{
    struct Node* prev = NULL;
    struct Node* current = *head_ref;
    struct Node* next;
    int len = 0;
    while (current != NULL) {
        len++;
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    *head_ref = prev;
    return len;
}

// Function to make an empty linked list of
// given size
struct Node* make_empty_list(int size)
{
    struct Node* head = NULL;
    while (size--)
        push(&head, 0);
    return head;
}

// Multiply contents of two linked lists => store
// in another list and return its head
struct Node* multiplyTwoLists(struct Node* first,
                           struct Node* second)
{
    // reverse the lists to multiply from end
    // m and n lengths of linked lists to make
    // and empty list
    int m = reverse(&first), n = reverse(&second);

    // make a list that will contain the result
    // of multiplication.
    // m+n+1 can be max size of the list
    struct Node* result = make_empty_list(m + n + 1);

    // pointers for traverse linked lists and also
    // to reverse them after
    struct Node *second_ptr = second,
          *result_ptr1 = result, *result_ptr2, *first_ptr;

    // multiply each Node of second list with first
    while (second_ptr) {

        int carry = 0;

        // each time we start from the next of Node
        // from which we started last time
        result_ptr2 = result_ptr1;

        first_ptr = first;

        while (first_ptr) {

            // multiply a first list's digit with a
            // current second list's digit
            int mul = first_ptr->data * second_ptr->data
                      + carry;

            // Assign the product to corresponding Node
            // of result
            result_ptr2->data += mul % 10;

            // now resultant Node itself can have more
            // than 1 digit
            carry = mul / 10 + result_ptr2->data / 10;
            result_ptr2->data = result_ptr2->data % 10;

            first_ptr = first_ptr->next;
            result_ptr2 = result_ptr2->next;
        }

        // if carry is remaining from last multiplication
        if (carry > 0) {
            result_ptr2->data += carry;
        }

        result_ptr1 = result_ptr1->next;
        second_ptr = second_ptr->next;
    }

    // reverse the result_list as it was populated
    // from last Node
    reverse(&result);
    reverse(&first);
    reverse(&second);

    // remove if there are zeros at starting
    while (result->data == 0) {
        struct Node* temp = result;
        result = result->next;
        free(temp);
    }

    // Return head of multiplication list
    return result;
}

// A utility function to print a linked list
void printList(struct Node* Node)
{
    while (Node != NULL) {
        printf("%d", Node->data);
        if (Node->next)
            printf("->");
        Node = Node->next;
    }
    printf("\n");
}

// Driver program to test above function
int main(void)
{
    struct Node* first = NULL;
    struct Node* second = NULL;

    // create first list 9->9->9->4->6->9
    push(&first, 9);
    push(&first, 6);
    push(&first, 4);
    push(&first, 9);
    push(&first, 9);
    push(&first, 9);
    printf("First List is: ");
    printList(first);

    // create second list 9->9->8->4->9
    push(&second, 9);
    push(&second, 4);
    push(&second, 8);
    push(&second, 9);
    push(&second, 9);
    printf("Second List is: ");
    printList(second);

    // Multiply the two lists and see result
    struct Node* result = multiplyTwoLists(first, second);
    printf("Resultant list is: ");
    printList(result);

    return 0;
}

Java

// Java program to multiply two numbers
// represented as linked lists
import java.io.*;

// Node class
class Node {
  int data;
  Node next;

  // Constructor to create a new node
  public Node(int data)
  {
    this.data = data;
    this.next = null;
  }
}

// LinkedList class
class LinkedList {
  Node head;

  // Constructor to initialize an empty linked list
  public LinkedList() { this.head = null; }

  // Method to add a new node at the beginning of the list
  public void push(int newData)
  {
    // Create a new node
    Node newNode = new Node(newData);

    // Make next of new node as head
    newNode.next = head;

    // Move the head to point to new node
    head = newNode;
  }

  // Method to print the linked list
  public void printList()
  {
    // Object to iterate the list
    Node ptr = head;

    if (head.data == 0) {
      ptr = head.next;
    }

    // Loop to iterate the list
    while (ptr != null) {
      System.out.print(ptr.data + " -> ");

      // Moving the iterating object to the next node
      ptr = ptr.next;
    }

    System.out.println();
  }
}

class GFG {

  // Function to reverse the linked list and return its
  // length
  public static int reverse(LinkedList headRef)
  {
    // Initializing prev and current at null and
    // starting node respectively
    Node prev = null;
    Node current = headRef.head;

    int Len = 0;

    // Loop to reverse the link of each node in the list
    while (current != null) {
      Len++;
      Node next = current.next;
      current.next = prev;
      prev = current;
      current = next;
    }

    // Assigning new starting object to main head object
    headRef.head = prev;

    // Returning the length of linked list
    return Len;
  }

  // Function to define an empty linked list of given size
  // and each element as zero
  public static LinkedList makeEmptyList(int size)
  {
    LinkedList head = new LinkedList();

    while (size-- > 0) {
      head.push(0);
    }

    // Returns the head object
    return head;
  }

  // Multiply contents of two linked lists and store it in
  // another list and return its head
  public static LinkedList
    multiplyTwoLists(LinkedList first, LinkedList second)
  {
    // Reverse the lists to multiply from the end and
    // calculate their lengths
    int m = reverse(first);
    int n = reverse(second);

    // Make a list that will contain the result of the
    // multiplication m + n + 1 can be the max size of
    // the list
    LinkedList result = makeEmptyList(m + n + 1);

    // Objects to iterate the lists and also to reverse
    // them after
    Node secondPtr = second.head;
    Node resultPtr1 = result.head;

    // Multiply each node of second list with first
    while (secondPtr != null) {
      int carry = 0;

      // Each time we start from the next node from
      // which we started last time
      Node resultPtr2 = resultPtr1;
      Node firstPtr = first.head;

      // Multiply a first list's digit with a current
      // second list's digit
      while (firstPtr != null) {
        int mul = (firstPtr.data * secondPtr.data
                   + carry);

        // Assign the product to corresponding node
        // of result
        resultPtr2.data += mul % 10;

        // Now resultant node itself can have more
        // than one digit
        carry = (mul / 10) + (resultPtr2.data / 10);
        resultPtr2.data = resultPtr2.data % 10;

        firstPtr = firstPtr.next;
        resultPtr2 = resultPtr2.next;
      }

      // If carry is remaining from last
      // multiplication
      if (carry > 0) {
        resultPtr2.data += carry;
      }

      resultPtr1 = resultPtr1.next;
      secondPtr = secondPtr.next;
    }

    // Reverse the result list
    reverse(result);

    // Return the head of result list
    return result;
  }

  public static void main(String[] args)
  {

    // Creating the first list
    LinkedList first = new LinkedList();
    first.push(9);
    first.push(6);
    first.push(4);
    first.push(9);
    first.push(9);
    first.push(9);
    System.out.print("First List is: ");
    first.printList();

    // Creating the second list
    LinkedList second = new LinkedList();
    second.push(9);
    second.push(4);
    second.push(8);
    second.push(9);
    second.push(9);
    System.out.print("Second List is: ");
    second.printList();

    // Multiplying the lists
    LinkedList result = multiplyTwoLists(first, second);
    System.out.print("Resultant List is: ");
    result.printList();
  }
}

// This code is contributed by lokesh.

Python3

# Python3 program to multiply two numbers
# represented as linked lists

# Node class
class Node:

    # Function to initialize the node object
    def __init__(self, data):

        self.data = data
        self.next = None

# Linked List Class
class LinkedList:

    # Function to initialize the
    # LinkedList class.
    def __init__(self):

        # Initialize head as None
        self.head = None

    # This function insert a new node at the
    # beginning of the linked list
    def push(self, new_data):

        # Create a new Node
        new_node = Node(new_data)

        # Make next of new Node as head
        new_node.next = self.head

        # Move the head to point to new Node
        self.head = new_node

    # Method to print the linked list
    def printList(self):

        # Object to iterate
        # the list
        ptr = self.head

        # Loop to iterate list
        while(ptr != None):
            print(ptr.data, '->', end = '')

            # Moving the iterating object
            # to next node
            ptr = ptr.next

        print()

# Function to reverse the linked
# list and return its length
def reverse(head_ref):

    # Initialising prev and current
    # at None and starting node
    # respectively.
    prev = None
    current = head_ref.head

    Len = 0

    # Loop to reverse the link
    # of each node in the list
    while(current != None):
        Len += 1
        Next = current.next
        current.next = prev
        prev = current
        current = Next

    # Assigning new starting object
    # to main head object.
    head_ref.head = prev

    # Returning the length of
    # linked list.
    return Len

# Function to define an empty
# linked list of given size and
# each element as zero.
def make_empty_list(size):

    head = LinkedList()

    while(size):
        head.push(0)
        size -= 1

    # Returns the head object.
    return head

# Multiply contents of two linked
# list store it in other list and
# return its head.
def multiplyTwoLists(first, second):

    # Reverse the list to multiply from
    # end m and n lengths of linked list
    # to make and empty list
    m = reverse(first)
    n = reverse(second)

    # Make a list that will contain the
    # result of multiplication.
    # m+n+1 can be max size of the list.
    result = make_empty_list(m + n + 1)

    # Objects for traverse linked list
    # and also to reverse them after.
    second_ptr = second.head
    result_ptr1 = result.head

    # Multiply each node of second
    # list with first.
    while(second_ptr != None):
        carry = 0

        # Each time we start from next
        # node from which we started last
        # time.
        result_ptr2 = result_ptr1
        first_ptr = first.head

        while(first_ptr != None):

            # Multiply a first list's digit
            # with a current second list's digit.
            mul = ((first_ptr.data) *
                  (second_ptr.data) + carry)

            # Assign the product to corresponding
            # node of result.
            result_ptr2.data += mul % 10

            # Now resultant node itself can have
            # more than one digit.
            carry = ((mul // 10) +
                     (result_ptr2.data // 10))
            result_ptr2.data = result_ptr2.data % 10

            first_ptr = first_ptr.next
            result_ptr2 = result_ptr2.next

        # If carry is remaining from
        # last multiplication
        if(carry > 0):
            result_ptr2.data += carry

        result_ptr1 = result_ptr1.next
        second_ptr = second_ptr.next

    # Reverse the result_list as it
    # was populated from last node
    reverse(result)
    reverse(first)
    reverse(second)

    # Remove starting nodes
    # containing zeroes.
    start = result.head
    while(start.data == 0):
        result.head = start.next
        start = start.next

    # Return the resultant multiplicated
    # linked list.
    return result

# Driver code
if __name__=='__main__':

    first = LinkedList()
    second = LinkedList()

    # Pushing elements at start of
    # first linked list.
    first.push(9)
    first.push(6)
    first.push(4)
    first.push(9)
    first.push(9)
    first.push(9)

    # Printing first linked list
    print("First list is: ", end = '')
    first.printList()

    # Pushing elements at start of
    # second linked list.
    second.push(9)
    second.push(4)
    second.push(8)
    second.push(9)
    second.push(9)

    # Printing second linked list.
    print("Second List is: ", end = '')
    second.printList()

    # Multiply two linked list and
    # print the result.
    result = multiplyTwoLists(first, second)
    print("Resultant list is: ", end = '')
    result.printList()

# This code is contributed by Amit Mangal

C#

// C# program to multiply two numbers
// represented as linked lists
using System;

// Node class
class Node
{
  public int data;
  public Node next;

  // Constructor to create a new node
  public Node(int data)
  {
    this.data = data;
    this.next = null;
  }
}

// LinkedList class
class LinkedList
{
  public Node head;

  // Constructor to initialize an empty linked list
  public LinkedList()
  {
    this.head = null;
  }

  // Method to add a new node at the beginning of the list
  public void Push(int newData)
  {
    // Create a new node
    Node newNode = new Node(newData);

    // Make next of new node as head
    newNode.next = head;

    // Move the head to point to new node
    head = newNode;
  }

  // Method to print the linked list
  public void PrintList()
  {
    // Object to iterate the list
    Node ptr = head;

    if (head.data == 0)
    {
      ptr = head.next;
    }

    // Loop to iterate the list
    while (ptr != null)
    {
      Console.Write(ptr.data + " -> ");

      // Moving the iterating object to the next node
      ptr = ptr.next;
    }

    Console.WriteLine();
  }
}

class GFG
{

  // Function to reverse the linked list and return its
  // length
  public static int Reverse(LinkedList headRef)
  {
    // Initializing prev and current at null and
    // starting node respectively
    Node prev = null;
    Node current = headRef.head;

    int Len = 0;

    // Loop to reverse the link of each node in the list
    while (current != null)
    {
      Len++;
      Node next = current.next;
      current.next = prev;
      prev = current;
      current = next;
    }

    // Assigning new starting object to main head object
    headRef.head = prev;

    // Returning the length of linked list
    return Len;
  }

  // Function to define an empty linked list of given size
  // and each element as zero
  public static LinkedList MakeEmptyList(int size)
  {
    LinkedList head = new LinkedList();

    while (size-- > 0)
    {
      head.Push(0);
    }

    // Returns the head object
    return head;
  }

  // Multiply contents of two linked lists and store it in
  // another list and return its head
  public static LinkedList
    MultiplyTwoLists(LinkedList first, LinkedList second)
  {
    // Reverse the lists to multiply from the end and
    // calculate their lengths
    int m = Reverse(first);
    int n = Reverse(second);

    // Make a list that will contain the result of the
    // multiplication m + n + 1 can be the max size of
    // the list
    LinkedList result = MakeEmptyList(m + n + 1);

    // Objects to iterate the lists and also to reverse
    // them after
    Node secondPtr = second.head;
    Node resultPtr1 = result.head;

    // Multiply each node of second list with first
    while (secondPtr != null)
    {
      int carry = 0;

      // Each time we start from the next node from
      // which we started last time
      Node resultPtr2 = resultPtr1;
      Node firstPtr = first.head;

      // Multiply a first list's digit with a current
      // second list's digit
      while (firstPtr != null)
      {
        int mul = (firstPtr.data * secondPtr.data
                   + carry);

        // Assign the product to corresponding node
        // of result
        resultPtr2.data += mul % 10;

        // Now resultant node itself can have more
        // than one digit
        carry = (mul / 10) + (resultPtr2.data / 10);
        resultPtr2.data = resultPtr2.data % 10;

        firstPtr = firstPtr.next;
        resultPtr2 = resultPtr2.next;
      }

      // If carry is remaining from last
      // multiplication
      if (carry > 0)
      {
        resultPtr2.data += carry;
      }

      resultPtr1 = resultPtr1.next;
      secondPtr = secondPtr.next;
    }

    // Reverse the result list
    Reverse(result);

    // Return the head of result list
    return result;
  }

  public static void Main(String[] args)
  {

    // Creating the first list
    LinkedList first = new LinkedList();
    first.Push(9);
    first.Push(6);
    first.Push(4);
    first.Push(9);
    first.Push(9);
    first.Push(9);
    Console.Write("First List is: ");
    first.PrintList();

    // Creating the second list
    LinkedList second = new LinkedList();
    second.Push(9);
    second.Push(4);
    second.Push(8);
    second.Push(9);
    second.Push(9);
    Console.Write("Second List is: ");
    second.PrintList();

    // Multiplying the lists
    LinkedList result = MultiplyTwoLists(first, second);
    Console.Write("Resultant List is: ");
    result.PrintList();
  }
}

Javascript

// JavaScript program to multiply two numbers
// represented as linked lists
// linked list node
class Node{
    constructor(data){
        this.data = data;
        this.next = null;
    }
}

// function to create a new node
// with given data
function newNode(data){
    return new Node(data);
}

// function to insert a node at the
// beginning of the linked list
function push(head_ref, new_data){
    // allocated node and put data
    let new_node = new Node(new_data);

    // link to old list of the new node
    new_node.next = head_ref;

    // move the head to point to the new node
    head_ref = new_node;
    return head_ref;
}

// function to reverse the linked list
// and return its length
function reverse(head_ref){
    let prev = null;
    let current = head_ref;
    let next;
    while(current != null){
        next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }
    head_ref = prev;
    return head_ref;
}

// function to make an empty linked list of
// given size
function make_empty_list(size){
    let head = null;
    while(size--){
        head = push(head, 0);
    }
    return head;
}

// function return the length of linked list
function len(head){
    let n = 0;
    while(head != null){
        n++;
        head = head.next;
    }
    return n;
}

// multiply contents of two linked lists => store
// in another list and return its head
function multiplyTwoLists(first, second){
    // reverse the lists to multiply from end
    // m and n lengths of linked lists to make
    // and empty list
    first = reverse(first);
    second = reverse(second);

    let m = len(first);
    let n = len(second);

    // make a list that will contain the result
    // of multiplication.
    // m+n+1 can be max size of the list
    let result = make_empty_list(m+n+1);

    // pointers for traverse linked lists and also
    // to reverse them after
    let second_ptr = second;
    let result_ptr1 = result;
    let result_ptr2;
    let first_ptr;

    // multiply each node of second list with first
    while(second_ptr){
        let carry = 0;

        // each time we start from the next of node
        // from which we started last time
        result_ptr2 = result_ptr1;

        first_ptr = first;

        while(first_ptr){
            // multiply a first list's digit with a
            // current second list's digit
            let mul = first_ptr.data * second_ptr.data + carry;

            // assign the product to corresponding node
            // of result
            result_ptr2.data += mul % 10;

            // now resultant node itself can have more
            // than 1 digit
            carry = parseInt(mul / 10) + parseInt(result_ptr2.data/10);
            result_ptr2.data = result_ptr2.data % 10;

            first_ptr = first_ptr.next;
            result_ptr2 = result_ptr2.next;
        }
        // if carry is remaining from last multiplication
        if (carry > 0) {
            result_ptr2.data += carry;
        }

        result_ptr1 = result_ptr1.next;
        second_ptr = second_ptr.next;
    }
    // reverse the result_list as it was populated
    // from last Node
    result = reverse(result);
    first = reverse(first);
    second = reverse(second);

    // remove if there are zeros at starting
    while (result.data == 0) {
        let temp = result;
        result = result.next;
    }

    // Return head of multiplication list
    return result;
}

// a utility function to print a linked list
function printList(Node){
    while(Node != null){
        console.log(Node.data);
        if(Node.next)
            console.log("->");
        Node = Node.next;
    }
    console.log("\n");
}

// driver code to test above functions
let first = null;
let second = null;

// create first list 9->9->9->4->6->9
first = push(first, 9);
first = push(first, 6);
first = push(first, 4);
first = push(first, 9);
first = push(first, 9);
first = push(first, 9);
console.log("First List is : ");
printList(first);

// create second list 9->9->8->4->9
second = push(second, 9);
second = push(second, 4);
second = push(second, 8);
second = push(second, 9);
second = push(second, 9);
console.log("Second List is : ");
printList(second);

// multiply the two lists and see result
let result = multiplyTwoLists(first, second);
console.log("Resultant list is : ");
printList(result);

// THIS  CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002)

Output: 

First List is: 9->9->9->4->6->9
Second List is: 9->9->8->4->9
Resultant list is: 9->9->7->9->5->9->8->0->1->8->1

Time complexity: O(M+N) where M and N are size of given two linked lists respectively

Auxiliary Space: O(1)

Note: we can take care of resultant node that can have more than 1 digit outside the loop just traverse the result list and add carry to next digit before reversing.