C++ Program For Adding 1 To A Number Represented As Linked List
Last Updated :
13 Apr, 2023
Improve
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++
// 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 codeint 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++
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 listvoid 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++
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 listvoid 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!
