C++ Program For Adding 1 To A Number Represented As Linked List
Last Updated :
13 Apr, 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.
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 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().
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 code
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 << "Resultant list is ";
printList(head);
return 0;
}
// This is code is contributed by rathbhupendra
Output:
List is 1999
Resultant list is 2000
Time Complexity: O(n), n is the number of elements in the linked list.
Auxiliary Space: O(1), as we are not taking any extra space.
Recursive Implementation:
We can recursively reach the last node and forward carry to previous nodes. A 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 the 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;
// New node becomes head now
return newNode;
}
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("");
}
// 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("Resultant list is ");
printList(head);
return 0;
}
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 <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("");
}
// 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("Resultant list is ");
printList(head);
return 0;
}
// This code is contribute by maddler
Output:
List is 1999
Resultant list is 2000
Time Complexity: O(n)
Auxiliary Space: O(1)
Please refer complete article on Add 1 to a number represented as linked list for more details!
Similar Reads
C++ 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-
12 min read
C++ 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
C++ 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
C++ Program For Sorting A Linked List Of 0s, 1s And 2s
Given a linked list of 0s, 1s and 2s, sort it.Examples: Input: 1 -> 1 -> 2 -> 0 -> 2 -> 0 -> 1 -> NULL Output: 0 -> 0 -> 1 -> 1 -> 1 -> 2 -> 2 -> NULL Input: 1 -> 1 -> 2 -> 1 -> 0 -> NULL Output: 0 -> 1 -> 1 -> 1 -> 2 -> NULL So
3 min read
C++ Program For Rotating A Linked List
Given a singly linked list, rotate the linked list counter-clockwise by k nodes. Where k is a given positive integer. For example, if the given linked list is 10->20->30->40->50->60 and k is 4, the list should be modified to 50->60->10->20->30->40. Assume that k is smal
6 min read
C++ Program for Deleting a Node in a Linked List
Write a C++ program to delete a node from the given link list.ExamplesInput: Linked List: 10 -> 20 -> 30 -> 40 -> 50, Position to delete: 3Output: 10 -> 20 -> 40 -> 50Explanation: The node at position 3 is removed. The list then connects node 20 directly to node 40.Input: Linked
6 min read
C++ 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
C++ Program For Merge Sort For Doubly Linked List
Given a doubly linked list, write a function to sort the doubly linked list in increasing order using merge sort.For example, the following doubly linked list should be changed to 24810 Recommended: Please solve it on "PRACTICE" first, before moving on to the solution. Merge sort for singly linked l
3 min read
C++ Program For Printing Reverse Of A Linked List Without Actually Reversing
Given a linked list, print reverse of it using a recursive function. For example, if the given linked list is 1->2->3->4, then output should be 4->3->2->1.Note that the question is only about printing the reverse. To reverse the list itself see this Difficulty Level: Rookie Algorit
2 min read
C++ Program For Segregating Even And Odd Nodes In A Linked List
Given a Linked List of integers, write a function to modify the linked list such that all even numbers appear before all the odd numbers in the modified linked list. Also, keep the order of even and odd numbers the same. Examples: Input: 17->15->8->12->10->5->4->1->7->6-
7 min read