Open In App
Related Articles

Add 1 to a number represented as linked list

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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;
 
    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 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 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)
    {
        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 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

# 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 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 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 Rohit

                    

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

                    

Javascript

<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 head
node 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 list
function 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>

                    

Output
List is 1999

Resultant list is 2000

Time Complexity: O(n), Here n is the number of nodes in the linked list.
Auxiliary Space: O(1), As constant extra space is used.

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 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;
}

                    

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 */

                    

Javascript

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

                    

Output
List is 1999

Resultant list is 2000

Time Complexity: O(n), Here n is the number of nodes in the linked list.
Auxiliary Space: O(n),The extra space is used in recursion call stack.

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("\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 by maddler

                    

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;
}
 
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 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 rajsanghavi9.

                    

Python3

# Recursive Python 3 program to add 1 to a linked list
class GFG :
    # Linked list node
    class Node :
        data = 0
        next = None
    # Function to create a new node with given data
    @staticmethod
    def  newNode( data) :
        new_node = GFG.Node()
        new_node.data = data
        new_node.next = None
        return new_node
    @staticmethod
    def  addOne( head) :
        # Return head of list after adding one
        ln = head
        if (head.next == None) :
            head.data += 1
            return head
        t = head
        prev = 0
        while (t.next != None) :
            if (t.data != 9) :
                ln = t
            t = t.next
        if (t.data == 9 and ln != None) :
            t = ln
            t.data += 1
            t = t.next
            while (t != None) :
                t.data = 0
                t = t.next
        else :
            t.data += 1
        return head
    # A utility function to print a linked list
    @staticmethod
    def printList( node) :
        while (node != None) :
            print(node.data, end ="")
            node = node.next
        print()
    # Driver code
    @staticmethod
    def main( args) :
        head = GFG.newNode(1)
        head.next = GFG.newNode(9)
        head.next.next = GFG.newNode(9)
        head.next.next.next = GFG.newNode(9)
        print("List is ", end ="")
        GFG.printList(head)
        head = GFG.addOne(head)
        print()
        print("Resultant list is ", end ="")
        GFG.printList(head)
     
if __name__=="__main__":
    GFG.main([])
     
    # This code is contributed by mukulsomukesh.

                    

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;
  }
 
  public 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;
 
    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 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 Abhijeet Kumar(abhijeet19403) */

                    

Javascript

<script>
 
// Recursive JavaScript program to add 1 to a linked list
 
// Linked list node
class Node
{
    constructor()
    {
        this.next = null;
        this.data = 0;
    }
}
     
// Function to create a new node with given data
function newNode(data)
{
    let new_node = new Node();
    new_node.data = data;
    new_node.next = null;
    return new_node;
}
     
function addOne(head)
{
         
    // Return head of list after adding one
    let ln = head;
     
    if (head.next == null)
    {
        head.data += 1;
        return head;
    }
     
    let t = head;
    let 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 list
function printList(node)
{
    while (node != null)
    {
        document.write(node.data);
        node = node.next;
    }
    document.write("</br>");
}
     
// Driver code
 
let 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);
 
// This code is contributed by shinjanpatra
 
</script>

                    

Output
List is 1999

Resultant list is 2000

Time Complexity: O(n), Here n is the number of nodes in the linked list.
Auxiliary Space: O(1), As constant extra space is used.

The easy way to add 1 in number represented by linked list.

The Approach:

    we first traverse over lined list and get the number that there in linked list simple while loop code and then add one to that number and then convert that number to linked list by simple while loop of(%10 and /10).

C++

#include <bits/stdc++.h>
#include<iostream>
using namespace std;
 
/* Linked list Node */
struct Node {
    int data;
    struct Node* next;
};
 
Node* newNode(int data)
{
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}
 
/* Function to insert a node at the
beginning of the Singly Linked List */
void push(Node** head_ref, int new_data)
{
    /* allocate node */
    Node* new_node = newNode(new_data);
    /* link the old list of the new node */
    new_node->next = (*head_ref);
    /* move the head to point to the new node */
    (*head_ref) = new_node;
}
 
void printList(Node* n)
{
    while (n) {
        cout << n->data << " ";
        n = n->next;
    }
    cout << endl;
}
// function working on addition.
Node* addTwoLists(Node*first){
  int num1=0;
  // get the number.
   while(first->next!=NULL){
     num1 +=first->data;
     num1*=10;
     first=first->next;
   }
   num1+=first->data;
   // add one to it.
   int num2=num1+1;
   Node* temp=NULL;
   //Node* result=temp;
  // made the linked list form it.
   while(num2!=0){
     int last=num2%10;
     push(&temp,last);
     num2=num2/10;
   }
  // return the list
   return temp;
}
int main() {
  Node* first = NULL;
  push(&first, 6);
  push(&first, 4);
  push(&first, 9);
  push(&first, 5);
  push(&first, 7);
  Node* ans = addTwoLists(first);
  cout << "Sum is of first : ";
  printList(ans);
  Node* second=NULL;
  push(&second, 9);
  push(&second, 9);
  push(&second, 9);
  push(&second, 1);
  cout << "Sum is of second : ";
  Node* res=addTwoLists(second);
  printList(res);
  return 0;
}

                    

Java

// Java code
import java.util.*;
 
/* Linked list Node */
class Node {
  int data;
  Node next;
 
  Node(int d) {
    data = d;
    next = null;
  }
}
 
class AddLinkedList
{
   
  // Function to insert a node at the
  // beginning of the Singly Linked List
  static Node push(Node head_ref, int new_data)
  {
     
    /* allocate node */
    Node new_node = new Node(new_data);
 
    /* link the old list of the new node */
    new_node.next = head_ref;
 
    /* move the head to point to the new node */
    head_ref = new_node;
    return head_ref;
  }
 
  static void printList(Node n) {
    while (n != null) {
      System.out.print(n.data + " ");
      n = n.next;
    }
    System.out.println();
  }
 
  // function working on addition.
  static Node addTwoLists(Node first) {
    int num1 = 0;
     
    // get the number.
    while (first.next != null) {
      num1 += first.data;
      num1 *= 10;
      first = first.next;
    }
    num1 += first.data;
     
    // add one to it.
    int num2 = num1 + 1;
    Node temp = null;
     
    // Node* result=temp;
    // made the linked list form it.
    while (num2 != 0) {
      int last = num2 % 10;
      temp = push(temp, last);
      num2 = num2 / 10;
    }
     
    // return the list
    return temp;
  }
 
  public static void main(String[] args) {
    Node first = null;
    first = push(first, 6);
    first = push(first, 4);
    first = push(first, 9);
    first = push(first, 5);
    first = push(first, 7);
    Node ans = addTwoLists(first);
    System.out.print("Sum is of first : ");
    printList(ans);
    Node second = null;
    second = push(second, 9);
    second = push(second, 9);
    second = push(second, 9);
    second = push(second, 1);
    System.out.print("Sum is of second : ");
    Node res = addTwoLists(second);
    printList(res);
  }
}
 
// This code is contributed by Utkarsh.

                    

Python3

# Linked list Node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
# Function to insert a node at the beginning of the Singly Linked List
def push(head_ref, new_data):
   
    # Allocate new node
    new_node = Node(new_data)
     
    # Link the old list of the new node
    new_node.next = head_ref
     
    # Move the head to point to the new node
    head_ref = new_node
    return head_ref
 
def printList(n):
    while n:
        print(n.data, end=" ")
        n = n.next
    print()
 
# Function working on addition.
def addTwoLists(first):
    num1 = 0
    # Get the number
    while first.next != None:
        num1 += first.data
        num1 *= 10
        first = first.next
    num1 += first.data
     
    # Add one to it
    num2 = num1 + 1
    temp = None
     
    # Made the linked list form it
    while num2 != 0:
        last = num2 % 10
        temp = push(temp, last)
        num2 //= 10
         
    # Return the list
    return temp
 
# Driver code
if __name__ == '__main__':
    first = None
    first = push(first, 6)
    first = push(first, 4)
    first = push(first, 9)
    first = push(first, 5)
    first = push(first, 7)
 
    ans = addTwoLists(first)
    print("Sum is of first: ", end="")
    printList(ans)
 
    second = None
    second = push(second, 9)
    second = push(second, 9)
    second = push(second, 9)
    second = push(second, 1)
 
    res = addTwoLists(second)
    print("Sum is of second: ", end="")
    printList(res)

                    

C#

// C# program of the above approach
using System;
 
/* Linked list Node */
class Node {
  public int data;
  public Node next;
 
  public Node(int d) {
    data = d;
    next = null;
  }
}
 
class AddLinkedList {
 
  // Function to insert a node at the
  // beginning of the Singly Linked List
  static Node push(Node head_ref, int new_data) {
    /* allocate node */
    Node new_node = new Node(new_data);
 
    /* link the old list of the new node */
    new_node.next = head_ref;
 
    /* move the head to point to the new node */
    head_ref = new_node;
    return head_ref;
  }
 
  static void printList(Node n) {
    while (n != null) {
      Console.Write(n.data + " ");
      n = n.next;
    }
    Console.WriteLine();
  }
 
  // function working on addition.
  static Node addTwoLists(Node first) {
    int num1 = 0;
 
    // get the number.
    while (first.next != null) {
      num1 += first.data;
      num1 *= 10;
      first = first.next;
    }
    num1 += first.data;
 
    // add one to it.
    int num2 = num1 + 1;
    Node temp = null;
 
    // Node* result=temp;
    // made the linked list form it.
    while (num2 != 0) {
      int last = num2 % 10;
      temp = push(temp, last);
      num2 = num2 / 10;
    }
 
    // return the list
    return temp;
  }
 
  static void Main(string[] args) {
    Node first = null;
    first = push(first, 6);
    first = push(first, 4);
    first = push(first, 9);
    first = push(first, 5);
    first = push(first, 7);
    Node ans = addTwoLists(first);
    Console.Write("Sum is of first : ");
    printList(ans);
    Node second = null;
    second = push(second, 9);
    second = push(second, 9);
    second = push(second, 9);
    second = push(second, 1);
    Console.Write("Sum is of second : ");
    Node res = addTwoLists(second);
    printList(res);
  }
}
 
// This code is contributed by Pushpesh Raj.

                    

Javascript

// Linked list Node
class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}
 
// Function to insert a node at the beginning of the Singly Linked List
function push(head_ref, new_data) {
  // Allocate new node
  const new_node = new Node(new_data);
 
  // Link the old list of the new node
  new_node.next = head_ref;
 
  // Move the head to point to the new node
  head_ref = new_node;
  return head_ref;
}
 
function printList(n) {
  let ans="";
  while (n) {
    ans = ans + n.data+" ";
    n = n.next;
  }
  console.log(ans);
}
 
// Function working on addition.
function addTwoLists(first) {
  let num1 = 0;
  // Get the number
  while (first.next != null) {
    num1 += first.data;
    num1 *= 10;
    first = first.next;
  }
  num1 += first.data;
 
  // Add one to it
  let num2 = num1 + 1;
  let temp = null;
 
  // Made the linked list form it
  while (num2 != 0) {
    const last = num2 % 10;
    temp = push(temp, last);
    num2 = Math.floor(num2 / 10);
  }
 
  // Return the list
  return temp;
}
 
// Driver code
let first = null;
first = push(first, 6);
first = push(first, 4);
first = push(first, 9);
first = push(first, 5);
first = push(first, 7);
 
let ans = addTwoLists(first);
console.log("Sum is of first: ");
printList(ans);
 
let second = null;
second = push(second, 9);
second = push(second, 9);
second = push(second, 9);
second = push(second, 1);
 
let res = addTwoLists(second);
console.log("Sum is of second: ");
printList(res);

                    


 Time Complexity: O(n), Here n is the number of nodes in the linked list.
Auxiliary Space: O(n), Need one temporary linked list to store result.



Last Updated : 27 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads