Related Articles

# Multiply a single digit number in place to a number represented as a Linked List

• Last Updated : 30 Aug, 2021

Given a linked list of N nodes where each node represents digits of a number and a single-digit number M, the task is to multiply the list by M in-place and print the resulting linked list.

Examples:

Input: Linked list: 1 → 2 → 7 → 3 → NULL, M = 3
Output: 3 → 8 → 1 → 9 → NULL
Explanation: The given linked list represents the number 1273. Multiplying 1273 with 3 = 1273*3 = 3819. Hence, the resulting linked list is
3 → 8 → 1 → 9 → NULL

Input: Linked list: 9 → 9 → 9 → NULL, M = 2
Output: 1 → 9 → 9 → 8 → NULL
Explanation: The given linked list represents the number 999. Multiplying 999 with 2 = 999*2 = 1998. Hence, the resulting linked list is
1 → 9 → 9 → 8 → NULL

Approach: Since we are allowed to reverse the LL and add at most 1 extra node to it, the idea to solve this problem is to first reverse the linked list. Then, traverse the linked list and start multiplying M with every node adding the carry generated and updating the carry after each multiplication step. Again, reverse the modified linked list and print the resulting list.

Below is the implementation of the above approach:

## C++14

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Node of a Linked List` `class` `Node {` `public``:` `    ``int` `data;` `    ``Node* next;` `};`   `// Function to create a new` `// node with given data` `Node* newNode(``int` `data)` `{` `    ``// Initialize new node` `    ``Node* new_node = ``new` `Node;`   `    ``// Set the data field of the node` `    ``new_node->data = data;` `    ``new_node->next = NULL;`   `    ``// Return the new node` `    ``return` `new_node;` `}`   `// Function to reverse the linked list` `Node* reverse(Node* head)` `{` `    ``Node* prev = NULL;` `    ``Node* current = head;` `    ``Node* next;`   `    ``// Traverse until curr!=null` `    ``while` `(current != NULL) {` `        ``next = current->next;` `        ``current->next = prev;` `        ``prev = current;` `        ``current = next;` `    ``}`   `    ``// Return the head of the` `    ``// reversed linked list` `    ``return` `prev;` `}`   `// Utility function to multiply a single digit` `// to a linked list` `Node* multiplyHelp(Node* head, ``int` `M)` `{` `    ``// Store the head of list` `    ``Node* res = head;`   `    ``// Stores the address of previous node` `    ``Node* prev = NULL;`   `    ``// Initially set carry as 0 and product as 1` `    ``int` `carry = 0, product = 1;`   `    ``while` `(head != NULL) {`   `        ``// Multiply M with each digit` `        ``product = head->data * M;`   `        ``// Add carry to product if carry exist` `        ``product += carry;`   `        ``// Update carry for next calculation` `        ``carry = product / 10;`   `        ``// Update the value of each nodes` `        ``head->data = product % 10;`   `        ``// Move head and temp pointers to next nodes` `        ``prev = head;` `        ``head = head->next;` `    ``}`   `    ``// If some carry is still there,` `    ``// add a new node to list` `    ``if` `(carry > 0)` `        ``prev->next = newNode(carry);`   `    ``// Return head of the resultant list` `    ``return` `res;` `}`   `// Function to multiply a single digit` `// to a linked list` `Node* multiply(Node* head, ``int` `M)` `{` `    ``// Reverse linked list` `    ``head = reverse(head);`   `    ``// Multiply M from left to right of reversed list` `    ``head = multiplyHelp(head, M);`   `    ``// Reverse the modified list and return its head` `    ``return` `reverse(head);` `}`   `// Function to print the linked list` `void` `printList(Node* node)` `{` `    ``while` `(node != NULL) {` `        ``cout << node->data;` `        ``node = node->next;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given Input list: 1->2->7->3` `    ``Node* head = newNode(1);` `    ``head->next = newNode(2);` `    ``head->next->next = newNode(7);` `    ``head->next->next->next = newNode(3);` `    ``int` `M = 3;`   `    ``// Function Call` `    ``head = multiply(head, M);`   `    ``// Print resultant list` `    ``printList(head);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG {`   `  ``// Node of a Linked List` `  ``static` `class` `Node {` `    ``int` `data;` `    ``Node next;` `  ``};`   `  ``// Function to create a new` `  ``// node with given data` `  ``static` `Node newNode(``int` `data)` `  ``{` `    `  `    ``// Initialize new node` `    ``Node new_node = ``new` `Node();`   `    ``// Set the data field of the node` `    ``new_node.data = data;` `    ``new_node.next = ``null``;`   `    ``// Return the new node` `    ``return` `new_node;` `  ``}`   `  ``// Function to reverse the linked list` `  ``static` `Node reverse(Node head) {` `    ``Node prev = ``null``;` `    ``Node current = head;` `    ``Node next;`   `    ``// Traverse until curr!=null` `    ``while` `(current != ``null``) {` `      ``next = current.next;` `      ``current.next = prev;` `      ``prev = current;` `      ``current = next;` `    ``}`   `    ``// Return the head of the` `    ``// reversed linked list` `    ``return` `prev;` `  ``}`   `  ``// Utility function to multiply a single digit` `  ``// to a linked list` `  ``static` `Node multiplyHelp(Node head, ``int` `M) {` `    ``// Store the head of list` `    ``Node res = head;`   `    ``// Stores the address of previous node` `    ``Node prev = ``null``;`   `    ``// Initially set carry as 0 and product as 1` `    ``int` `carry = ``0``, product = ``1``;`   `    ``while` `(head != ``null``) {`   `      ``// Multiply M with each digit` `      ``product = head.data * M;`   `      ``// Add carry to product if carry exist` `      ``product += carry;`   `      ``// Update carry for next calculation` `      ``carry = product / ``10``;`   `      ``// Update the value of each nodes` `      ``head.data = product % ``10``;`   `      ``// Move head and temp pointers to next nodes` `      ``prev = head;` `      ``head = head.next;` `    ``}`   `    ``// If some carry is still there,` `    ``// add a new node to list` `    ``if` `(carry > ``0``)` `      ``prev.next = newNode(carry);`   `    ``// Return head of the resultant list` `    ``return` `res;` `  ``}`   `  ``// Function to multiply a single digit` `  ``// to a linked list` `  ``static` `Node multiply(Node head, ``int` `M)` `  ``{` `    `  `    ``// Reverse linked list` `    ``head = reverse(head);`   `    ``// Multiply M from left to right of reversed list` `    ``head = multiplyHelp(head, M);`   `    ``// Reverse the modified list and return its head` `    ``return` `reverse(head);` `  ``}`   `  ``// Function to print the linked list` `  ``static` `void` `printList(Node node) {` `    ``while` `(node != ``null``) {` `      ``System.out.print(node.data);` `      ``node = node.next;` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args) ` `  ``{` `    `  `    ``// Given Input list: 1.2.7.3` `    ``Node head = newNode(``1``);` `    ``head.next = newNode(``2``);` `    ``head.next.next = newNode(``7``);` `    ``head.next.next.next = newNode(``3``);` `    ``int` `M = ``3``;`   `    ``// Function Call` `    ``head = multiply(head, M);`   `    ``// Print resultant list` `    ``printList(head);`   `  ``}` `}`   `// This code contributed by gauravrajput1 `

## C#

 `// C# program for the above approach` `using` `System;`   `public` `class` `GFG {`   `  ``// Node of a Linked List` `  ``class` `Node {` `    ``public` `int` `data;` `    ``public` `Node next;` `  ``};`   `  ``// Function to create a new` `  ``// node with given data` `  ``static` `Node newNode(``int` `data)` `  ``{` `    `  `    ``// Initialize new node` `    ``Node new_node = ``new` `Node();`   `    ``// Set the data field of the node` `    ``new_node.data = data;` `    ``new_node.next = ``null``;`   `    ``// Return the new node` `    ``return` `new_node;` `  ``}`   `  ``// Function to reverse the linked list` `  ``static` `Node reverse(Node head) {` `    ``Node prev = ``null``;` `    ``Node current = head;` `    ``Node next;`   `    ``// Traverse until curr!=null` `    ``while` `(current != ``null``) {` `      ``next = current.next;` `      ``current.next = prev;` `      ``prev = current;` `      ``current = next;` `    ``}`   `    ``// Return the head of the` `    ``// reversed linked list` `    ``return` `prev;` `  ``}`   `  ``// Utility function to multiply a single digit` `  ``// to a linked list` `  ``static` `Node multiplyHelp(Node head, ``int` `M) {` `    ``// Store the head of list` `    ``Node res = head;`   `    ``// Stores the address of previous node` `    ``Node prev = ``null``;`   `    ``// Initially set carry as 0 and product as 1` `    ``int` `carry = 0, product = 1;`   `    ``while` `(head != ``null``) {`   `      ``// Multiply M with each digit` `      ``product = head.data * M;`   `      ``// Add carry to product if carry exist` `      ``product += carry;`   `      ``// Update carry for next calculation` `      ``carry = product / 10;`   `      ``// Update the value of each nodes` `      ``head.data = product % 10;`   `      ``// Move head and temp pointers to next nodes` `      ``prev = head;` `      ``head = head.next;` `    ``}`   `    ``// If some carry is still there,` `    ``// add a new node to list` `    ``if` `(carry > 0)` `      ``prev.next = newNode(carry);`   `    ``// Return head of the resultant list` `    ``return` `res;` `  ``}`   `  ``// Function to multiply a single digit` `  ``// to a linked list` `  ``static` `Node multiply(Node head, ``int` `M)` `  ``{` `    `  `    ``// Reverse linked list` `    ``head = reverse(head);`   `    ``// Multiply M from left to right of reversed list` `    ``head = multiplyHelp(head, M);`   `    ``// Reverse the modified list and return its head` `    ``return` `reverse(head);` `  ``}`   `  ``// Function to print the linked list` `  ``static` `void` `printList(Node node) {` `    ``while` `(node != ``null``) {` `      ``Console.Write(node.data);` `      ``node = node.next;` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args) ` `  ``{` `    `  `    ``// Given Input list: 1.2.7.3` `    ``Node head = newNode(1);` `    ``head.next = newNode(2);` `    ``head.next.next = newNode(7);` `    ``head.next.next.next = newNode(3);` `    ``int` `M = 3;`   `    ``// Function Call` `    ``head = multiply(head, M);`   `    ``// Print resultant list` `    ``printList(head);`   `  ``}` `}`   `// This code contributed by Princi Singh`

## Javascript

 ``

Output

`3819`

Time Complexity: O(N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up
Recommended Articles
Page :