Related Articles

# Add the given digit to a number stored in a linked list using recursion

• Difficulty Level : Expert
• Last Updated : 09 Jun, 2021

Given a linked list which represents an integer number where each node is a digit of the represented integer. The task is to add a given digit N to the represented integer.
Examples:

Input: LL = 9 -> 9 -> 3 -> NULL, N = 7
Output: 1 -> 0 -> 0 -> 0 -> NULL
993 + 7 = 1000
Input: LL = 2 -> 9 -> 9 -> NULL, N = 5
Output: 3 -> 0 -> 4 -> NULL

Approach: An iterative approach to solve this problem has been discussed here. In this article, a recursive approach will be discussed.
The idea is to traverse the LinkedList recursively until the last node is reached. Once the last node has been reached, add the value of N to it. After adding, if the value is more than 9 then keep the carry and set mode (digit % 10) value to the node value and add carry to the previous stack frame node, and continue until all the stack frames are cleared from the stack.
If there is a carry after all the stack frames have been cleared then create a new node with this value which will be the new head of the linked list pointing to the previous head.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include``using` `namespace` `std;` `// Node class contains value``// and next node reference``struct` `ListNode``{``    ``int` `value;``    ``ListNode* next;``};` `// To store the carry``int` `carry = 0;``void` `addNewValue(ListNode*, ``int``);` `// Function that calls the recursive method``// addNewValue to add a digit to the``// number represented as the linked list``ListNode* addValue(ListNode* head,``                   ``int` `addValue)``{` `  ``// Add the digit recursively``  ``addNewValue(head, addValue);` `  ``// If there is a carry after the addition``  ``if` `(carry != 0)``  ``{` `    ``// Create a new node``    ``ListNode* newHead = ``new` `ListNode();` `    ``// Assign it with carry``    ``newHead->value = carry;` `    ``// Make it point to the head of``    ``// the linked list``    ``newHead->next = head;``    ``carry = 0;` `    ``// Make it the new head``    ``return` `newHead;``  ``}` `  ``// If there's not carry then``  ``// return the previous head``  ``else``  ``{``    ``return` `head;``  ``}``}` `// Recursive function to add a digit to the number``// represented as the given linked list``void` `addNewValue(ListNode* head,``                 ``int` `addValue)``{` `  ``// If it is the last node in the list``  ``if` `(head->next == NULL)``  ``{` `    ``// Add the digit``    ``int` `val = head->value + addValue;` `    ``// Find the carry if any``    ``head->value = val % 10;``    ``carry = val / 10;``  ``}``  ``else``  ``{` `    ``// Preserve the current node's value and call``    ``// the recursive function for the next node``    ``int` `val = head->value;``    ``addNewValue(head->next, addValue);``    ``val = val + carry;``    ``head->value = val % 10;``    ``carry = val / 10;``  ``}``}` `// Utility function to print the linked list``void` `printList(ListNode* node)``{``  ``while` `(node != NULL)``  ``{``    ``cout << node->value << ``" -> "``;``    ``node = node->next;``  ``}``  ``cout<<``"NULL"``;``}` `// Driver code``int` `main()``{` `  ``// Create the linked list 9 -> 9 -> 3 -> NULL``  ``ListNode* head = ``new` `ListNode();``  ``head->value = 9;``  ``head->next = ``new` `ListNode();``  ``head->next->value = 9;``  ``head->next->next = ``new` `ListNode();``  ``head->next->next->value = 3;``  ``head->next->next->next = NULL;` `  ``// Digit to be added``  ``int` `n = 7;``  ``head = addValue(head, n);` `  ``printList(head);``}` `// This code is contributed by rutvik_56`

## Java

 `// Java implementation of the approach` `// Node class contains value``// and next node reference``class` `ListNode {``    ``int` `value;``    ``ListNode next;``}` `class` `GFG {` `    ``// To store the carry``    ``private` `static` `int` `carry = ``0``;` `    ``// Function that calls the recursive method``    ``// addNewValue to add a digit to the``    ``// number represented as the linked list``    ``public` `static` `ListNode addValue(ListNode head, ``int` `addValue)``    ``{` `        ``// Add the digit recursively``        ``addNewValue(head, addValue);` `        ``// If there is a carry after the addition``        ``if` `(carry != ``0``) {` `            ``// Create a new node``            ``ListNode newHead = ``new` `ListNode();` `            ``// Assign it with carry``            ``newHead.value = carry;` `            ``// Make it point to the head of``            ``// the linked list``            ``newHead.next = head;``            ``carry = ``0``;` `            ``// Make it the new head``            ``return` `newHead;``        ``}` `        ``// If there's not carry then``        ``// return the previous head``        ``else` `{``            ``return` `head;``        ``}``    ``}` `    ``// Recursive function to add a digit to the number``    ``// represented as the given linked list``    ``private` `static` `void` `addNewValue(ListNode head, ``int` `addValue)``    ``{` `        ``// If it is the last node in the list``        ``if` `(head.next == ``null``) {` `            ``// Add the digit``            ``int` `val = head.value + addValue;` `            ``// Find the carry if any``            ``head.value = val % ``10``;``            ``carry = val / ``10``;``        ``}``        ``else` `{` `            ``// Preserve the current node's value and call``            ``// the recursive function for the next node``            ``int` `val = head.value;``            ``addNewValue(head.next, addValue);``            ``val = val + carry;``            ``head.value = val % ``10``;``            ``carry = val / ``10``;``        ``}``    ``}` `    ``// Utility function to print the linked list``    ``private` `static` `void` `printList(ListNode node)``    ``{``        ``while` `(node != ``null``) {``            ``System.out.print(node.value + ``" -> "``);``            ``node = node.next;``        ``}``        ``System.out.print(``"NULL"``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``// Create the linked list 9 -> 9 -> 3 -> NULL``        ``ListNode head = ``new` `ListNode();``        ``head.value = ``9``;``        ``head.next = ``new` `ListNode();``        ``head.next.value = ``9``;``        ``head.next.next = ``new` `ListNode();``        ``head.next.next.value = ``3``;``        ``head.next.next.next = ``null``;` `        ``// Digit to be added``        ``int` `n = ``7``;``        ``head = addValue(head, n);` `        ``printList(head);``    ``}``}`

## Python

 `# Python implementation of the approach` `# Node class contains value``# and next node reference``class` `ListNode:``    ``def` `__init__(``self``, new_data):``        ``self``.value ``=` `new_data``        ``self``.``next` `=` `None` `# To store the carry``carry ``=` `0` `# Function that calls the recursive method``# addNewValue to add a digit to the``# number represented as the linked list``def` `addValue(head, addValue):` `    ``global` `carry``    ` `    ``# Add the digit recursively``    ``addNewValue(head, addValue)` `    ``# If there is a carry after the addition``    ``if` `(carry !``=` `0``) :` `        ``# Create a node``        ``newHead ``=` `ListNode(``0``)` `        ``# Assign it with carry``        ``newHead.value ``=` `carry` `        ``# Make it point to the head of``        ``# the linked list``        ``newHead.``next` `=` `head``        ``carry ``=` `0` `        ``# Make it the head``        ``return` `newHead``        ` `    ``# If there's not carry then``    ``# return the previous head``    ``else` `:``        ``return` `head``    ` `# Recursive function to add a digit to the number``# represented as the given linked list``def` `addNewValue(head,addValue):``    ` `    ``global` `carry` `    ``# If it is the last node in the list``    ``if` `(head.``next` `=``=` `None``) :` `        ``# Add the digit``        ``val ``=` `head.value ``+` `addValue` `        ``# Find the carry if any``        ``head.value ``=` `val ``%` `10``        ``carry ``=` `int``(val ``/` `10``)``    ` `    ``else` `:` `        ``# Preserve the current node's value and call``        ``# the recursive function for the next node``        ``val ``=` `head.value``        ``addNewValue(head.``next``, addValue)``        ``val ``=` `val ``+` `carry``        ``head.value ``=` `val ``%` `10``        ``carry ``=` `int``(val ``/` `10``)``        ` `# Utility function to print the linked list``def` `printList(node):``    ` `    ``while` `(node !``=` `None``) :``        ``print``(node.value ,end``=` `" -> "``)``        ``node ``=` `node.``next``        ` `    ``print``(``"None"``)``    ` `# Driver code` `# Create the linked list 9 -> 9 -> 3 -> None``head ``=` `ListNode(``0``)``head.value ``=` `9``head.``next` `=` `ListNode(``0``)``head.``next``.value ``=` `9``head.``next``.``next` `=` `ListNode(``0``)``head.``next``.``next``.value ``=` `3``head.``next``.``next``.``next` `=` `None` `# Digit to be added``n ``=` `7``head ``=` `addValue(head, n)` `printList(head)` `# This code is contributed by Arnab Kundu`

## C#

 `// C# implementation of the approach``using` `System;` `// Node class contains value``// and next node reference``public` `class` `ListNode``{``    ``public` `int` `value;``    ``public` `ListNode next;``}` `class` `GFG``{` `    ``// To store the carry``    ``private` `static` `int` `carry = 0;` `    ``// Function that calls the recursive method``    ``// addNewValue to add a digit to the``    ``// number represented as the linked list``    ``public` `static` `ListNode addValue(ListNode head,``                                     ``int` `addValue)``    ``{` `        ``// Add the digit recursively``        ``addNewValue(head, addValue);` `        ``// If there is a carry after the addition``        ``if` `(carry != 0)``        ``{` `            ``// Create a new node``            ``ListNode newHead = ``new` `ListNode();` `            ``// Assign it with carry``            ``newHead.value = carry;` `            ``// Make it point to the head of``            ``// the linked list``            ``newHead.next = head;``            ``carry = 0;` `            ``// Make it the new head``            ``return` `newHead;``        ``}` `        ``// If there's not carry then``        ``// return the previous head``        ``else``        ``{``            ``return` `head;``        ``}``    ``}` `    ``// Recursive function to add a digit to the number``    ``// represented as the given linked list``    ``private` `static` `void` `addNewValue(ListNode head,``                                     ``int` `addValue)``    ``{` `        ``// If it is the last node in the list``        ``if` `(head.next == ``null``)``        ``{` `            ``// Add the digit``            ``int` `val = head.value + addValue;` `            ``// Find the carry if any``            ``head.value = val % 10;``            ``carry = val / 10;``        ``}``        ``else``        ``{` `            ``// Preserve the current node's value and call``            ``// the recursive function for the next node``            ``int` `val = head.value;``            ``addNewValue(head.next, addValue);``            ``val = val + carry;``            ``head.value = val % 10;``            ``carry = val / 10;``        ``}``    ``}` `    ``// Utility function to print the linked list``    ``private` `static` `void` `printList(ListNode node)``    ``{``        ``while` `(node != ``null``)``        ``{``            ``Console.Write(node.value + ``" -> "``);``            ``node = node.next;``        ``}``        ``Console.Write(``"NULL"``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{` `        ``// Create the linked list 9 -> 9 -> 3 -> NULL``        ``ListNode head = ``new` `ListNode();``        ``head.value = 9;``        ``head.next = ``new` `ListNode();``        ``head.next.value = 9;``        ``head.next.next = ``new` `ListNode();``        ``head.next.next.value = 3;``        ``head.next.next.next = ``null``;` `        ``// Digit to be added``        ``int` `n = 7;``        ``head = addValue(head, n);` `        ``printList(head);``    ``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``
Output:
`1 -> 0 -> 0 -> 0 -> NULL`

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