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

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:



  1. There can be overflow after adding the number in the last digit i.e. value at the node is greater than 9.
  2. 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <iostream>
using namespace std;
  
// Node structure containing data
// and pointer to the next Node
struct node {
  
    int key;
    node* next;
  
    node(int n)
    {
        key = n;
        next = NULL;
    }
};
  
// Linked list class
class LinkedList {
  
    node* head;
  
public:
    // Deafault 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 list
void 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 list
void 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 list
void 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 beginnig 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
int 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
  
// Node structure containing data
// and pointer to the next Node
class node 
{
    int key;
    node next;
  
    node(int n) 
    {
        key = n;
        next = null;
    }
};
  
// Linked list class
class LinkedList
{
    static node head;
  
    // Deafault 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 beginnig 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
  
// Node structure containing data
// and pointer to the next Node
public class node 
{
    public int key;
    public node next;
  
    public node(int n) 
    {
        key = n;
        next = null;
    }
};
  
// Linked list class
public class List
{
    static node head;
  
    // Deafault 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 beginnig 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

chevron_right


Output:

1 -> 9 -> 9 -> NULL
2 -> 0 -> 4 -> NULL

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : Rajput-Ji, 29AjayKumar

Article Tags :
Practice Tags :


3


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.