Add 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)

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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.

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 (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 calulation  
        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 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

// 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 calulation 
        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) 
    { 
        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

// Java program to add 1 to a linked list  
class 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 calulation  
        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

# Python3 program to add 1 to a linked list  
import sys 
import 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  
    head = reverseList(head) 
    temp = head 
    carry = 1
    while(temp): 
        temp.data += carry 
        if temp.data % 10 == 0: 
            # update carry for next calulation  
            carry = 1
            temp.data = 0
        else: 
            # update carry for next calulation  
            carry = 0
        temp = temp.next
  
    # Reverse the modified list              
    return reverseList(head) 
  
# 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 code 
if __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 Vikash Kumar 37 

C#

// C# program to add 1 to a linked list 
using 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 calulation  
        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 

Output:

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++

// 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 list 
void 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

// Recursive Java program to add 1 to a linked list 
class 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 

Python

# Recursive Python program to add 1 to a linked list 
  
# Node class  
class 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 data  
def 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 list 
def 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 

C#

// Recursive C# program to add 1 to a linked list  
using 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 */

Output:

List is 1999

Resultant list is 2000

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

My Personal Notes

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

C++

C

Java

Python3

C#

C++

Java

Python

C#

Recommended Posts: