Add 1 to a number represented as linked list - GeeksforGeeks

04 Feb, 2022
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 : 
Reverse given linked list. For example, 1-> 9-> 9 -> 9 is converted to 9-> 9 -> 9 ->1.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.Reverse modified linked list and return head.
Reverse given linked list. For example, 1-> 9-> 9 -> 9 is converted to 9-> 9 -> 9 ->1.
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.
Reverse modified linked list and return head.
Below is the implementation of above steps. 
C++
C
Java
Python3
C#
Javascript
// 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 headnode of resultant list */Node *addOneUtil(Node *head){    // res is head node of the resultant list    Node* res = head;    Node *temp;     int carry = 1, sum;     while (head != NULL) //while both lists exist    {        // 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 listvoid printList(Node *node){    while (node != NULL)    {        cout << node->data;        node = node->next;    }    cout<<endl;} /* Driver program to test above function */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 << "\nResultant list is ";    printList(head);     return 0;} // This is code is contributed by rathbhupendra
// 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;} /* 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 (head != NULL) //while both lists exist    {        // 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 listvoid printList(Node *node){    while (node != NULL)    {        printf("%d", node->data);        node = node->next;    }    printf("\n");} /* Driver program to test above function */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("\nResultant list is ");    printList(head);     return 0;}
// Java program to add 1 to a linked listclass GfG {     /* Linked list node */    static class Node {        int data;        Node next;    }     /* Function to create a new node with given data */    static 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 */    static Node reverse(Node head)    {        Node prev = null;        Node current = head;        Node next = null;        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 */    static Node addOneUtil(Node head)    {        // res is head node of the resultant list        Node res = head;        Node temp = null, prev = null;         int carry = 1, sum;         while (head != null) // while both lists exist        {            // 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().    static 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    static void printList(Node node)    {        while (node != null) {            System.out.print(node.data);            node = node.next;        }        System.out.println();    }     /* Driver code */    public static void main(String[] args)    {        Node head = newNode(1);        head.next = newNode(9);        head.next.next = newNode(9);        head.next.next.next = newNode(9);         System.out.print("List is ");        printList(head);         head = addOne(head);        System.out.println();        System.out.print("Resultant list is ");        printList(head);    }} // This code is contributed by prerna saini
# Python3 program to add 1 to a linked listimport sysimport math # Linked list node  class Node:    def __init__(self, data):        self.data = data        self.next = None # Function to create a new node with given data */  def newNode(data):    return Node(data) # Function to reverse the linked list */  def reverseList(head):    if not head:        return    curNode = head    prevNode = head    nextNode = head.next    curNode.next = None     while(nextNode):        curNode = nextNode        nextNode = nextNode.next        curNode.next = prevNode        prevNode = curNode     return curNode # Adds one to a linked lists and return the head# node of resultant list  def addOne(head):     # Reverse linked list and add one to head    head = reverseList(head)    k = head    carry = 0    prev = None    head.data += 1     # update carry for next calculation    while(head != None) and (head.data > 9 or carry > 0):        prev = head        head.data += carry        carry = head.data // 10        head.data = head.data % 10        head = head.next     if carry > 0:        prev.next = Node(carry)    # Reverse the modified list    return reverseList(k) # A utility function to print a linked list  def printList(head):    if not head:        return    while(head):        print("{}".format(head.data), end="")        head = head.next  # Driver codeif __name__ == '__main__':    head = newNode(1)    head.next = newNode(9)    head.next.next = newNode(9)    head.next.next.next = newNode(9)     print("List is: ", end="")    printList(head)     head = addOne(head)     print("\nResultant list is: ", end="")    printList(head)  # This code is contributed by Rohit
// C# program to add 1 to a linked listusing System; class GfG {     /* Linked list node */    public class Node {        public int data;        public Node next;    }     /* Function to create a new node with given data */    static 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 */    static Node reverse(Node head)    {        Node prev = null;        Node current = head;        Node next = null;        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 */    static Node addOneUtil(Node head)    {        // res is head node of the resultant list        Node res = head;        Node temp = null, prev = null;         int carry = 1, sum;         while (head != null) // while both lists exist        {            // 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().    static 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    static void printList(Node node)    {        while (node != null) {            Console.Write(node.data);            node = node.next;        }        Console.WriteLine();    }     /* Driver code */    public static void Main(String[] args)    {        Node head = newNode(1);        head.next = newNode(9);        head.next.next = newNode(9);        head.next.next.next = newNode(9);         Console.Write("List is ");        printList(head);         head = addOne(head);        Console.WriteLine();        Console.Write("Resultant list is ");        printList(head);    }} // This code contributed by Rajput-Ji
<script> // Javascript program to add 1 to a linked list /* Linked list node */class Node{    constructor()    {        this.data = 0;        this.next = null;    }}; /* Function to create a new node with given data */function newNode(data){    var new_node = new Node();    new_node.data = data;    new_node.next = null;    return new_node;} /* Function to reverse the linked list */function reverse(head){    var prev = null;    var current = head;    var 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 headnode of resultant list */function addOneUtil(head){    // res is head node of the resultant list    var res = head;    var temp, prev = null;     var carry = 1, sum;     while (head != null) //while both lists exist    {        // 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().function addOne(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 listfunction printList(node){    while (node != null)    {        document.write( node.data);        node = node.next;    }    document.write("<br>");} /* Driver program to test above function */var head = newNode(1);head.next = newNode(9);head.next.next = newNode(9);head.next.next.next = newNode(9);document.write( "List is ");printList(head);head = addOne(head);document.write( "<br>Resultant list is ");printList(head); // This code is contributed by rrrtnx.</script>
List is 1999

Resultant list is 2000
Recursive Implementation: We can recursively reach the last node and forward carry to previous nodes. 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 recursive solution.
C++
Java
Python
C#
Javascript
// 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;        return newNode; // New node becomes head now    }     return head;} // A utility function to print a linked listvoid printList(Node* node){    while (node != NULL) {        printf("%d", node->data);        node = node->next;    }    printf("\n");} /* 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("\nResultant list is ");    printList(head);     return 0;}
// Recursive Java program to add 1 to a linked listclass GfG {     /* Linked list node */    static class Node    {        int data;        Node next;    }     /* Function to create a new node with given data */    static 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.    static 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().    static 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 > 0)        {            Node newNode = newNode(carry);            newNode.next = head;            return newNode; // New node becomes head now        }         return head;    }     // A utility function to print a linked list    static void printList(Node node)    {        while (node != null)        {            System.out.print(node.data);            node = node.next;        }        System.out.println();    }     /* Driver code */    public static void main(String[] args)    {        Node head = newNode(1);        head.next = newNode(9);        head.next.next = newNode(9);        head.next.next.next = newNode(9);         System.out.print("List is ");        printList(head);         head = addOne(head);        System.out.println();        System.out.print("Resultant list is ");        printList(head);    }} // This code is contributed by shubham96301
# Recursive Python program to add 1 to a linked list # Node classclass Node:     # Constructor to initialize the node object    def __init__(self, data):        self.data = data        self.next = None # Function to create a new node with given datadef newNode(data):     new_node = Node(0)    new_node.data = data    new_node.next = None    return new_node # Recursively add 1 from end to beginning and returns# carry after all nodes are processed.def addWithCarry(head):     # If linked list is empty, then    # return carry    if (head == None):        return 1     # Add carry returned be next node call    res = head.data + addWithCarry(head.next)     # Update data and return new carry    head.data = int((res) % 10)    return int((res) / 10) # This function mainly uses addWithCarry().def addOne(head):     # Add 1 to linked list from end to beginning    carry = addWithCarry(head)     # If there is carry after processing all nodes,    # then we need to add a new node to linked list    if (carry != 0):             newNode = Node(0)        newNode.data = carry        newNode.next = head        return newNode # New node becomes head now         return head # A utility function to print a linked listdef printList(node):     while (node != None):             print( node.data,end = "")        node = node.next         print("\n") # Driver program to test above function head = newNode(1)head.next = newNode(9)head.next.next = newNode(9)head.next.next.next = newNode(9) print("List is ")printList(head) head = addOne(head) print("\nResultant list is ")printList(head)  # This code is contributed by Arnab Kundu
// Recursive C# program to add 1 to a linked listusing System; class GfG{     /* Linked list node */    public class Node    {        public int data;        public Node next;    }     /* Function to create a new node with given data */    public static 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.    public static 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().    public static Node addOne(Node head)    {         // Add 1 to linked list from end to beginning        int carry = addWithCarry(head);        Node newNodes = null;                 // If there is carry after processing all nodes,        // then we need to add a new node to linked list        if (carry > 0)        {            newNodes = newNode(carry);            newNodes.next = head;            return newNodes; // New node becomes head now        }         return head;    }     // A utility function to print a linked list    public static void printList(Node node)    {        while (node != null)        {            Console.Write(node.data);            node = node.next;        }        Console.WriteLine();    }     /* Driver code */    public static void Main(String[] args)    {        Node head = newNode(1);        head.next = newNode(9);        head.next.next = newNode(9);        head.next.next.next = newNode(9);         Console.Write("List is ");        printList(head);         head = addOne(head);        Console.WriteLine();        Console.Write("Resultant list is ");        printList(head);    }} /* This code contributed by PrinciRaj1992 */
<script>       // Recursive JavaScript program      // to add 1 to a linked list      /* Linked list node */      class Node {        constructor() {          this.data = 0;          this.next = null;        }      }       /* Function to create a new node with given data */      function newNode(data) {        var 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.      function addWithCarry(head) {        // If linked list is empty, then        // return carry        if (head == null) return 1;         // Add carry returned be next node call        var res = head.data + addWithCarry(head.next);         // Update data and return new carry        head.data = res % 10;        return parseInt(res / 10);      }       // This function mainly uses addWithCarry().      function addOne(head) {        // Add 1 to linked list from end to beginning        var carry = addWithCarry(head);        var newNodes = null;         // If there is carry after processing all nodes,        // then we need to add a new node to linked list        if (carry > 0) {          newNodes = newNode(carry);          newNodes.next = head;          return newNodes; // New node becomes head now        }         return head;      }       // A utility function to print a linked list      function printList(node) {        while (node != null) {          document.write(node.data);          node = node.next;        }        document.write("<br>");      }       /* Driver code */      var head = newNode(1);      head.next = newNode(9);      head.next.next = newNode(9);      head.next.next.next = newNode(9);       document.write("List is ");      printList(head);       head = addOne(head);      document.write("<br>");      document.write("Resultant list is ");      printList(head);       </script>
  
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++
Java
// 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 listvoid printList(Node* node){    while (node != NULL) {        printf("%d->", node->data);        node = node->next;    }    printf("NULL");    printf("\n");} /* 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("\nResultant list is ");    printList(head);     return 0;}// This code is contribute bu maddler
// Recursive Java program to add 1 to a linked listclass GFG{ // Linked list nodestatic class Node{    int data;    Node next;} // Function to create a new node with given datastatic Node newNode(int data){    Node new_node = new Node();    new_node.data = data;    new_node.next = null;    return new_node;} static Node addOne(Node head){         // 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 != null)    {        if (t.data != 9)        {            ln = t;        }        t = t.next;    }    if (t.data == 9 && ln != null)    {        t = ln;        t.data += 1;        t = t.next;        while (t != null)        {            t.data = 0;            t = t.next;        }    }    else    {        t.data += 1;    }    return head;} // A utility function to print a linked liststatic void printList(Node node){    while (node != null)    {        System.out.print(node.data);        node = node.next;    }    System.out.println();} // Driver codepublic static void main(String[] args){    Node head = newNode(1);    head.next = newNode(9);    head.next.next = newNode(9);    head.next.next.next = newNode(9);     System.out.print("List is ");    printList(head);     head = addOne(head);    System.out.println();    System.out.print("Resultant list is ");    printList(head);}} // This code is contributed by rajsanghavi9.
  
List is 1999

Resultant list is 2000
 
YouTubeGeeksforGeeks500K subscribersAdd 1 to a number represented as linked list | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 14:09•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=utc8bwTDjLk" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
 
This article is contributed by Aditya Goel. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
 
 
 
prerna saini
Rajput-Ji
rathbhupendra
nobody_cares
princiraj1992
Vikash Kumar 37
andrew1234
rv720468
maddler
rrrtnx
rdtank
rajsanghavi9
gulshankumarar231
simmytarika5
sambitskd3
Amazon
Linked List
Amazon
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
LinkedList in Java
Doubly Linked List | Set 1 (Introduction and Insertion)
Linked List vs Array
Queue - Linked List Implementation
Implementing a Linked List in Java using Class
Implement a stack using singly linked list
Merge two sorted linked lists
Circular Linked List | Set 1 (Introduction and Applications)
Merge Sort for Linked Lists
Remove duplicates from a sorted linked list