Related Articles

# Add 1 to a number represented as linked list

• Difficulty Level : Medium
• Last Updated : 23 Aug, 2021

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

// Move head and second pointers to next nodes
}

// 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().
{
// Reverse linked list

// Add one from left to right of reversed
// list

// Reverse the modified list
}

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

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

// Move head and second pointers to next nodes
}

// 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().
{
// Reverse linked list

// Add one from left to right of reversed
// list

// Reverse the modified list
}

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

System.out.print(“List is “);

System.out.println();
System.out.print(“Resultant list is “);
}
}

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

return
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

carry = 0
prev = None

# update carry for next calculation
while(head != None) and (head.data > 9 or carry > 0):
carry = head.data // 10

if carry > 0:
prev.next = Node(carry)
# Reverse the modified list
return reverseList(k)

# A utility function to print a linked list

return

# Driver code
if __name__ == ‘__main__’:

print(“List is: “, end=””)

print(“\nResultant list is: “, end=””)

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

// Move head and second pointers to next nodes
}

// 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().
{
// Reverse linked list

// Add one from left to right of reversed
// list

// Reverse the modified list
}

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

Console.Write(“List is “);

Console.WriteLine();
Console.Write(“Resultant list is “);
}
}

// This code contributed by Rajput-Ji

## Javascript

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

// 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("
"); }

/* 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( "
Resultant list is "); printList(head);

// This code is contributed by rrrtnx.

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

/* 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.
{
// If linked list is empty, then
// return carry
if (head == NULL)
return 1;

// Add carry returned be next node call

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

// This function mainly uses addWithCarry().
{
// Add 1 to linked list from end to beginning

// 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;
return newNode; // New node becomes head now
}

}

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

printf(“List is “);

printf(“\nResultant list is “);

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

// If linked list is empty, then
// return carry
if (head == null)
return 1;

// Add carry returned be next node call

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

// This function mainly uses addWithCarry().
{

// Add 1 to linked list from end to beginning

// 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);
return newNode; // New node becomes head now
}

}

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

System.out.print(“List is “);

System.out.println();
System.out.print(“Resultant list is “);
}
}

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

# If linked list is empty, then
# return carry
if (head == None):
return 1

# Add carry returned be next node call

# Update data and return new carry
head.data = int((res) % 10)
return int((res) / 10)

# This function mainly uses addWithCarry().

# Add 1 to linked list from end to beginning

# 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
return newNode # New node becomes head now

# 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

print(“List is “)

print(“\nResultant list is “)

# 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.
{

// If linked list is empty, then
// return carry
if (head == null)
return 1;

// Add carry returned be next node call

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

// This function mainly uses addWithCarry().
{

// Add 1 to linked list from end to beginning
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);
return newNodes; // New node becomes head now
}

}

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

Console.Write(“List is “);

Console.WriteLine();
Console.Write(“Resultant list is “);
}
}

/* This code contributed by PrinciRaj1992 */

## Javascript

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

// A utility function to print a linked list function printList(node) { while (node != null) { document.write(node.data); node = node.next; } document.write("
"); }

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

"); document.write("Resultant list is "); printList(head);

Output
```List is 1999

Resultant list is 2000```

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

## C++

// Recursive C++ program to add 1 to a linked list
#include

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

{
// Your Code here
// return head of list after adding one
Node* ln = head;
if (head->next == NULL) {
}
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);
t = ln;
}
else {
t = ln;
t->data += 1;
t = t->next;
}
while (t) {
t->data = 0;
t = t->next;
}
}
else {
t->data += 1;
}
}

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

printf(“List is “);

printf(“\nResultant list is “);

return 0;
}
// This code is contribute bu 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;
}

{

// Return head of list after adding one
Node ln = head;

if (head.next == null)
{
}

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

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

System.out.print(“List is “);

System.out.println();
System.out.print(“Resultant list is “);
}
}

// This code is contributed by rajsanghavi9.

Output
```List is 1999

Resultant list is 2000```