Add the given digit to a number stored in a linked list - GeeksforGeeks

06 Jul, 2021
Given a linked list which represents an integer number where every node is a digit if the represented integer. The task is to add a given digit N to the represented integer.
Examples: 
Input: 9 -> 9 -> 3 -> NULL, N = 7 Output: 9 -> 9 -> 3 -> NULL 1 -> 0 -> 0 -> 0 -> NULL
Input: 2 -> 9 -> 9 -> NULL, N = 5 Output: 2 -> 9 -> 9 -> NULL 3 -> 0 -> 4 -> NULL 
Approach: We have already discussed the approach for adding 1 to a number stored in linked list int this article but the code requires reversal of the linked list. In this post, we have extended the problem to adding any digit to the number stored in a linked list and achieving the same without reversal or recursion. 
The idea is to traverse the list and while traversing maintain a pointer to the last node whose value is less than 9. This is because we are adding a single digit to the number stored in the linked list. So, the maximum value of carry (if present) can be 1. Suppose we start propagating the carry from the least significant digit towards most significant digit, then the propagation will stop as soon as it finds a number less than 9. 
After the complete traversal of the list in this manner, we have finally reached the last node of the linked list and also maintained a pointer to the latest node whose value is less than 9. Two cases can arise: 
There can be overflow after adding the number in the last digit i.e. value at the node is greater than 9.No overflow i.e. after adding the value at the node is less than 10.
There can be overflow after adding the number in the last digit i.e. value at the node is greater than 9.
No overflow i.e. after adding the value at the node is less than 10.
In the first case, we have to propagate the carry from the latest node whose value is less than 9 to the last node.In the second case, we don’t have to do anything else. 
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <iostream>using namespace std; // Node structure containing data// and pointer to the next Nodestruct node {     int key;    node* next;     node(int n)    {        key = n;        next = NULL;    }}; // Linked list classclass LinkedList {     node* head; public:    // Default constructor for    // creating empty list    LinkedList();     // Insert a node in linked list    void insert(node* n);     // Adding a single digit to the list    void addDigit(int n);     // Print the linked list    void printList();}; LinkedList::LinkedList(){    // Empty List    head = NULL;} // Function to insert a node at the// head of the linked listvoid LinkedList::insert(node* n){    // Empty List    if (head == NULL)        head = n;     // Insert in the beginning of the list    else {        n->next = head;        head = n;    }} // Function to print the linked listvoid LinkedList::printList(){    node* ptr = head;     while (ptr) {        cout << ptr->key << " -> ";        ptr = ptr->next;    }    cout << "NULL" << endl;} // Function to add a digit to the integer// represented as a linked listvoid LinkedList::addDigit(int n){     // To keep track of the last node    // whose value is less than 9    node* lastNode = NULL;    node* curr = head;     while (curr->next) {         // If found a node with value        // less than 9        if (curr->key < 9)            lastNode = curr;         // Otherwise keep traversing        // the list till end        curr = curr->next;    }     // Add the given digit to the last node    curr->key = curr->key + n;     // In case of overflow in the last node    if (curr->key > 9) {         curr->key = curr->key % 10;         // If the list is of the        // form 9 -> 9 -> 9 -> ...        if (lastNode == NULL) {             // Insert a node at the beginning as            // there would be overflow in the            // head in this case            insert(new node(1));             // Adjust the lastNode pointer to            // propagate the carry effect to            // all the nodes of the list            lastNode = head->next;        }         // Forward propagate carry effect        while (lastNode != curr) {            lastNode->key = (lastNode->key + 1) % 10;            lastNode = lastNode->next;        }    }} // Driver codeint main(){    // Creating the linked list    LinkedList* l1 = new LinkedList();     // Adding elements to the linked list    l1->insert(new node(9));    l1->insert(new node(9));    l1->insert(new node(1));     // Printing the original list    l1->printList();     // Adding the digit    l1->addDigit(5);     // Printing the modified list    l1->printList();     return 0;}
// Java implementation of the approach // Node structure containing data// and pointer to the next Nodeclass node{    int key;    node next;     node(int n)    {        key = n;        next = null;    }}; // Linked list classclass LinkedList{    static node head;     // Default constructor for    // creating empty list    public LinkedList()    {        // Empty List        head = null;    }     // Function to insert a node at the    // head of the linked list    void insert(node n)    {                 // Empty List        if (head == null)            head = n;         // Insert in the beginning of the list        else        {            n.next = head;            head = n;        }    }     // Function to print the linked list    void printList()    {        node ptr = head;         while (ptr != null)        {            System.out.print(ptr.key + "->");            ptr = ptr.next;        }        System.out.print("null" + "\n");    }     // Function to add a digit to the integer    // represented as a linked list    void addDigit(int n)    {         // To keep track of the last node        // whose value is less than 9        node lastNode = null;        node curr = head;         while (curr.next != null)        {             // If found a node with value            // less than 9            if (curr.key < 9)                lastNode = curr;             // Otherwise keep traversing            // the list till end            curr = curr.next;        }         // Add the given digit to the last node        curr.key = curr.key + n;         // In case of overflow in the last node        if (curr.key > 9)        {            curr.key = curr.key % 10;             // If the list is of the            // form 9.9.9....            if (lastNode == null)            {                 // Insert a node at the beginning as                // there would be overflow in the                // head in this case                insert(new node(1));                 // Adjust the lastNode pointer to                // propagate the carry effect to                // all the nodes of the list                lastNode = head.next;            }             // Forward propagate carry effect            while (lastNode != curr)            {                lastNode.key = (lastNode.key + 1) % 10;                lastNode = lastNode.next;            }        }    }     // Driver code    public static void main(String[] args)    {                 // Creating the linked list        LinkedList l1 = new LinkedList();         // Adding elements to the linked list        l1.insert(new node(9));        l1.insert(new node(9));        l1.insert(new node(1));         // Printing the original list        l1.printList();         // Adding the digit        l1.addDigit(5);         // Printing the modified list        l1.printList();    }} // This code is contributed by Rajput-Ji
# Python3 implementation of the approach # Node structure containing data# and pointer to the next Nodeclass node:     def __init__(self, key):         self.key = key        self.next = None # Linked list classclass LinkedList:     def __init__(self):                 self.head = None     # Function to insert a node at the    # head of the linked list    def insert(self, n):         # Empty List        if (self.head == None):            self.head = n         # Insert in the beginning of the list        else:            n.next = self.head;            self.head = n     # Function to print the linked list    def printList(self):         ptr = self.head         while (ptr != None):            print(ptr.key, end = ' -> ')            ptr = ptr.next                     print('NULL')            # Function to add a digit to the integer    # represented as a linked list    def addDigit(self, n):             # To keep track of the last node        # whose value is less than 9        lastNode = None        curr = self.head             while (curr.next != None):                     # If found a node with value            # less than 9            if (curr.key < 9):                lastNode = curr                 # Otherwise keep traversing            # the list till end            curr = curr.next             # Add the given digit to the last node        curr.key = curr.key + n             # In case of overflow in the last node        if (curr.key > 9):            curr.key = curr.key % 10                 # If the list is of the            # form 9 . 9 . 9 . ...            if (lastNode == None):                             # Insert a node at the beginning as                # there would be overflow in the                # self.head in this case                self.insert(node(1))                     # Adjust the lastNode pointer to                # propagate the carry effect to                # all the nodes of the list                lastNode = self.head.next                 # Forward propagate carry effect            while (lastNode != curr):                lastNode.key = (lastNode.key + 1) % 10                lastNode = lastNode.next             # Driver codeif __name__=='__main__':         # Creating the linked list    l1 = LinkedList()      # Adding elements to the linked list    l1.insert(node(9))    l1.insert(node(9))    l1.insert(node(1))      # Printing the original list    l1.printList()      # Adding the digit    l1.addDigit(5)      # Printing the modified list    l1.printList()  # This code is contributed by rutvik_56
// C# implementation of the approachusing System; // Node structure containing data// and pointer to the next Nodepublic class node{    public int key;    public node next;     public node(int n)    {        key = n;        next = null;    }}; // Linked list classpublic class List{    static node head;     // Default constructor for    // creating empty list    public List()    {        // Empty List        head = null;    }     // Function to insert a node at the    // head of the linked list    void insert(node n)    {                 // Empty List        if (head == null)            head = n;         // Insert in the beginning of the list        else        {            n.next = head;            head = n;        }    }     // Function to print the linked list    void printList()    {        node ptr = head;         while (ptr != null)        {            Console.Write(ptr.key + "->");            ptr = ptr.next;        }        Console.Write("null" + "\n");    }     // Function to add a digit to the integer    // represented as a linked list    void addDigit(int n)    {         // To keep track of the last node        // whose value is less than 9        node lastNode = null;        node curr = head;         while (curr.next != null)        {             // If found a node with value            // less than 9            if (curr.key < 9)                lastNode = curr;             // Otherwise keep traversing            // the list till end            curr = curr.next;        }         // Add the given digit to the last node        curr.key = curr.key + n;         // In case of overflow in the last node        if (curr.key > 9)        {            curr.key = curr.key % 10;             // If the list is of the            // form 9.9.9....            if (lastNode == null)            {                 // Insert a node at the beginning as                // there would be overflow in the                // head in this case                insert(new node(1));                 // Adjust the lastNode pointer to                // propagate the carry effect to                // all the nodes of the list                lastNode = head.next;            }             // Forward propagate carry effect            while (lastNode != curr)            {                lastNode.key = (lastNode.key + 1) % 10;                lastNode = lastNode.next;            }        }    }     // Driver code    public static void Main(String[] args)    {                 // Creating the linked list        List l1 = new List();         // Adding elements to the linked list        l1.insert(new node(9));        l1.insert(new node(9));        l1.insert(new node(1));         // Printing the original list        l1.printList();         // Adding the digit        l1.addDigit(5);         // Printing the modified list        l1.printList();    }} // This code is contributed by 29AjayKumar
<script> // JavaScript implementation of the approach // Node structure containing data// and pointer to the next Nodeclass node{    constructor(n)    {        this.key = n;        this.next = null    }}; // Linked list classvar head = null; // Default constructor for// creating empty listfunction List(){    // Empty List    head = null;}// Function to insert a node at the// head of the linked listfunction insert(n){         // Empty List    if (head == null)        head = n;    // Insert in the beginning of the list    else    {        n.next = head;        head = n;    }}// Function to print the linked listfunction printList(){    var ptr = head;    while (ptr != null)    {        document.write(ptr.key + " -> ");        ptr = ptr.next;    }    document.write("null" + "<br>");}// Function to add a digit to the integer// represented as a linked listfunction addDigit(n){    // To keep track of the last node    // whose value is less than 9    var lastNode = null;    var curr = head;    while (curr.next != null)    {        // If found a node with value        // less than 9        if (curr.key < 9)            lastNode = curr;        // Otherwise keep traversing        // the list till end        curr = curr.next;    }    // Add the given digit to the last node    curr.key = curr.key + n;    // In case of overflow in the last node    if (curr.key > 9)    {        curr.key = curr.key % 10;        // If the list is of the        // form 9.9.9....        if (lastNode == null)        {            // Insert a node at the beginning as            // there would be overflow in the            // head in this case            insert(new node(1));            // Adjust the lastNode pointer to            // propagate the carry effect to            // all the nodes of the list            lastNode = head.next;        }        // Forward propagate carry effect        while (lastNode != curr)        {            lastNode.key = (lastNode.key + 1) % 10;            lastNode = lastNode.next;        }    }}// Driver code// Adding elements to the linked listinsert(new node(9));insert(new node(9));insert(new node(1));// Printing the original listprintList();// Adding the digitaddDigit(5);// Printing the modified listprintList();  </script>
1 -> 9 -> 9 -> NULL
2 -> 0 -> 4 -> NULL
 
Rajput-Ji
29AjayKumar
arorakashish0911
rutvik_56
itsok
simmytarika5
Microsoft
Linked List
Microsoft
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Circular Linked List | Set 2 (Traversal)
Swap nodes in a linked list without swapping data
Circular Singly Linked List | Insertion
Given a linked list which is sorted, how will you insert in sorted way
Program to implement Singly Linked List in C++ using class
Delete a node in a Doubly Linked List
Real-time application of Data Structures
Insert a node at a specific position in a linked list
Linked List Implementation in C#
Priority Queue using Linked List