Skip to content
Related Articles

Related Articles

Improve Article

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<bits/stdc++.h>
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




<script>
 
// JavaScript implementation of the approach
 
// Node class contains value
// and next node reference
class ListNode {
        constructor() {
                this.value = 0;
                this.next = null;
             }
        }
         
// To store the carry
let carry = 0;
 
// Function that calls the recursive method
// addNewValue to add a digit to the
// number represented as the linked list
function addValue( head, addValue)
{
 
    // Add the digit recursively
    addNewValue(head, addValue);
 
    // If there is a carry after the addition
    if (carry != 0) {
 
        // Create a new node
        var 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
function addNewValue( head, addValue)
{
 
    // If it is the last node in the list
    if (head.next == null) {
 
        // Add the digit
        let val = head.value + addValue;
 
        // Find the carry if any
        head.value = val % 10;
        carry = Math.floor(val / 10);
    }
    else {
 
        // Preserve the current node's value and call
        // the recursive function for the next node
        let val = head.value;
        addNewValue(head.next, addValue);
        val = val + carry;
        head.value = val % 10;
        carry = Math.floor(val / 10);
        }
    }
 
// Utility function to print the linked list
function printList( node)
{
    while (node != null) {
        document.write(node.value + " -> ");
        node = node.next;
    }
    document.write("NULL");
}
 
// Driver Code
 
// Create the linked list 9 -> 9 -> 3 -> NULL
var 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
let n = 7;
head = addValue(head, n);
 
printList(head);
     
</script>
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
Recommended Articles
Page :