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)
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++
#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 *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 cout << "List is ";
printList(head);
head = addOne(head);
cout << "\nResultant list is ";
printList(head);
return 0;
}
// This is code is contributed by rathbhupendra
void printList(Node *node)
{
while (node != NULL)
{
cout << node->data;
node = node->next;
}
cout<
head->next->next = newNode(9);
head->next->next->next = newNode(9);
Java
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
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#
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
/* 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("
");
}
/* 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.
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++
#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.
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
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
# 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#
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
/* 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("
");
}
/* 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("
");
document.write("Resultant list is ");
printList(head);
