Java Program For Adding 1 To A Number Represented As Linked List
Last Updated :
29 Mar, 2023
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.
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 both lists exist
while (head != null)
{
// 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
Output:
List is 1999
Resultant list is 2000
Time Complexity: O(n)
Auxiliary Space: O(1)
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.
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;
// New node becomes head now
return newNode;
}
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
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
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.
Output:
List is 1999
Resultant list is 2000
Please refer complete article on Add 1 to a number represented as linked list for more details!
Similar Reads
Java Program For Adding Two Numbers Represented By Linked Lists- Set 2 Given two numbers represented by two linked lists, write a function that returns the sum list. The sum list is linked list representation of the addition of two input numbers. It is not allowed to modify the lists. Also, not allowed to use explicit extra space (Hint: Use Recursion). Example : Input:
8 min read
Java Program To Add Two Numbers Represented By Linked Lists- Set 1 Given two numbers represented by two lists, write a function that returns the sum list. The sum list is a list representation of the addition of two input numbers. Example: Input:Â List1: 5->6->3 // represents number 563Â List2: 8->4->2 // represents number 842Â Output:Â Resultant list: 1->4->0->5 // re
4 min read
Java Program To Subtract Two Numbers Represented As Linked Lists Given two linked lists that represent two large positive numbers. Subtract the smaller number from the larger one and return the difference as a linked list. Note that the input lists may be in any order, but we always need to subtract smaller from the larger ones.It may be assumed that there are no
5 min read
Java Program To Multiply Two Numbers Represented By Linked Lists Given two numbers represented by linked lists, write a function that returns the multiplication of these two linked lists. Examples: Input: 9->4->6 8->4 Output: 79464 Input: 3->2->1 1->2 Output: 3852Recommended: Please solve it on "PRACTICE" first, before moving on to the solution.
3 min read
Java Program for Reverse a linked list Given a pointer to the head node of a linked list, the task is to reverse the linked list. We need to reverse the list by changing links between nodes. Examples: Input: Head of following linked list 1->2->3->4->NULLOutput: Linked list should be changed to, 4->3->2->1->NULL In
3 min read
Java Program For Cloning A Linked List With Next And Random Pointer- Set 2 We have already discussed 2 different ways to clone a linked list. In this post, one more simple method to clone a linked list is discussed. Recommended: Please solve it on "PRACTICE" first, before moving on to the solution. The idea is to use Hashing. Below is algorithm. Traverse the original link
4 min read
Java Program to Create a Singly Linked List and Count the Number of Nodes Linked List is a linear data structure. Linked list elements are not stored at a contiguous location, the elements are linked using pointers. Singly Linked list is the collection of nodes, where each node has two parts one is the data and other is the linked part. Example: Input : AddNodes = {2, 3,
3 min read
Java Program For Reversing A Doubly Linked List Given a Doubly Linked List, the task is to reverse the given Doubly Linked List. See below diagrams for example. (a) Original Doubly Linked List (b) Reversed Doubly Linked List Here is a simple method for reversing a Doubly Linked List. All we need to do is swap prev and next pointers for all nodes,
5 min read
Java Program to Delete a Node From the Ending of the Circular Linked List In this article, we will learn about deleting a node from the ending of a circular linked list. Consider the linked list as shown below:Â Example:Input : 5->3->4->(head node)Output: 5->3->(head node)We will first initialize the list and add some data into it with the addNode() method a
3 min read
Java Program to Search an Element in a Linked List Prerequisite: LinkedList in java LinkedList is a linear data structure where the elements are not stored in contiguous memory locations. Every element is a separate object known as a node with a data part and an address part. The elements are linked using pointers or references. Linked Lists are pre
5 min read