C++ Program For Adding 1 To A Number Represented As Linked List

Number is represented in linked list such that each digit corresponds to a node in linked list. Add 1 to it. For example 1999 is represented as (1-> 9-> 9 -> 9) and adding 1 to it should change it to (2->0->0->0) 

Below are the steps : 

1. Reverse given linked list. For example, 1-> 9-> 9 -> 9 is converted to 9-> 9 -> 9 ->1.
2. Start traversing linked list from leftmost node and add 1 to it. If there is a carry, move to the next node. Keep moving to the next node while there is a carry.
3. Reverse modified linked list and return head.

Below is the implementation of above steps. 

C++

// C++ program to add 1 to a
// linked list
#include <bits/stdc++.h>
using namespace std;

// Linked list node
class Node
{
    public:
    int data;
    Node* next;
};

/* Function to create a new node
   with given data */
Node *newNode(int data)
{
    Node *new_node = new Node;
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}

// Function to reverse the linked list
Node *reverse(Node *head)
{
    Node * prev = NULL;
    Node * current = head;
    Node * next;
    while (current != NULL)
    {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    return prev;
}

/* Adds one to a linked lists and
   return the head node of resultant
   list */
Node *addOneUtil(Node *head)
{
    // res is head node of the
    // resultant list
    Node* res = head;
    Node *temp, *prev = NULL;

    int carry = 1, sum;

    // while both lists exist
    while (head != NULL)
    {
        // Calculate value of next digit
        // in resultant list. The next digit
        // is sum of following things
        // (i) Carry
        // (ii) Next digit of head list (if
        // there is a next digit)
        sum = carry + head->data;

        // Update carry for next calculation
        carry = (sum >= 10)? 1 : 0;

        // Update sum if it is greater
        // than 10
        sum = sum % 10;

        // Create a new node with sum
        // as data
        head->data = sum;

        // Move head and second pointers
        // to next nodes
        temp = head;
        head = head->next;
    }

    // If some carry is still there, add
    // a new node to result list.
    if (carry > 0)
        temp->next = newNode(carry);

    // return head of the resultant list
    return res;
}

// This function mainly uses addOneUtil().
Node* addOne(Node *head)
{
    // Reverse linked list
    head = reverse(head);

    // Add one from left to right of
    // reversed list
    head = addOneUtil(head);

    // Reverse the modified list
    return reverse(head);
}

// A utility function to print a
// linked list
void printList(Node *node)
{
    while (node != NULL)
    {
        cout << node->data;
        node = node->next;
    }
    cout<<endl;
}

// Driver code
int main(void)
{
    Node *head = newNode(1);
    head->next = newNode(9);
    head->next->next = newNode(9);
    head->next->next->next = newNode(9);

    cout << "List is ";
    printList(head);

    head = addOne(head);

    cout << "Resultant list is ";
    printList(head);

    return 0;
}
// This is code is contributed by rathbhupendra

Output:

List is 1999
Resultant list is 2000

Time Complexity: O(n), n is the number of elements in the linked list.
Auxiliary Space: O(1), as we are not taking any extra space.

Recursive Implementation:
We can recursively reach the last node and forward carry to previous nodes. A recursive solution doesn’t require reversing of linked list. We can also use a stack in place of recursion to temporarily hold nodes.

Below is the implementation of the recursive solution:

C++

// Recursive C++ program to add 1 to
// a linked list
#include <bits/stdc++.h>

// Linked list node
struct Node
{
    int data;
    Node* next;
};

/* Function to create a new
   node with given data */
Node* newNode(int data)
{
    Node* new_node = new Node;
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}

// Recursively add 1 from end to
// beginning and returns carry
// after all nodes are processed.
int addWithCarry(Node* head)
{
    // If linked list is empty,
    // then return carry
    if (head == NULL)
        return 1;

    // Add carry returned be next
    // node call
    int res = head->data + addWithCarry(head->next);

    // Update data and return new carry
    head->data = (res) % 10;
    return (res) / 10;
}

// This function mainly uses addWithCarry().
Node* addOne(Node* head)
{
    // Add 1 to linked list from end
    // to beginning
    int carry = addWithCarry(head);

    // If there is carry after processing
    // all nodes, then we need to add a
    // new node to linked list
    if (carry)
    {
        Node* newNode = new Node;
        newNode->data = carry;
        newNode->next = head;

        // New node becomes head now
        return newNode;
    }

    return head;
}

// A utility function to print
// a linked list
void printList(Node* node)
{
    while (node != NULL)
    {
        printf("%d", node->data);
        node = node->next;
    }
    printf("");
}

// Driver code
int main(void)
{
    Node* head = newNode(1);
    head->next = newNode(9);
    head->next->next = newNode(9);
    head->next->next->next = newNode(9);

    printf("List is ");
    printList(head);

    head = addOne(head);

    printf("Resultant list is ");
    printList(head);

    return 0;
}

Output:

List is 1999
Resultant list is 2000

Simple approach and easy implementation: The idea is to store the last non 9 digit pointer so that if the last pointer is zero we can replace all the nodes after stored node(which contains the location of last digit before 9) to 0 and add the value of the stored node by 1

C++

// Recursive C++ program to add 1 to
// a linked list
#include <bits/stdc++.h>

// Linked list node
struct Node
{
    int data;
    Node* next;
};

/* Function to create a new
   node with given data */
Node* newNode(int data)
{
    Node* new_node = new Node;
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}

Node* addOne(Node* head)
{
    // Your Code here
    // return head of list after
    // adding one
    Node* ln = head;
    if (head->next == NULL)
    {
        head->data += 1;
        return head;
    }
    Node* t = head;
    int prev;
    while (t->next)
    {
        if (t->data != 9)
        {
            ln = t;
        }
        t = t->next;
    }
    if (t->data == 9 &&
        ln != NULL)
    {
        if (ln->data == 9 &&
            ln == head)
        {
            Node* temp = newNode(1);
            temp->next = head;
            head = temp;
            t = ln;
        }
        else
        {
            t = ln;
            t->data += 1;
            t = t->next;
        }
        while (t)
       {
            t->data = 0;
            t = t->next;
        }
    }
    else
    {
        t->data += 1;
    }
    return head;
}

// A utility function to print
// a linked list
void printList(Node* node)
{
    while (node != NULL)
    {
        printf("%d->",
                node->data);
        node = node->next;
    }
    printf("NULL");
    printf("");
}

// Driver code
int main(void)
{
    Node* head = newNode(1);
    head->next = newNode(9);
    head->next->next = newNode(9);
    head->next->next->next = newNode(9);

    printf("List is ");
    printList(head);

    head = addOne(head);

    printf("Resultant list is ");
    printList(head);

    return 0;
}
// This code is contribute by maddler

Output:

List is 1999
Resultant list is 2000

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

Please refer complete article on Add 1 to a number represented as linked list for more details!