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.

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 *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; ` `    ``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 ``void` `printList(Node *node) ``{ ``    ``while` `(node != NULL) ``    ``{ ``        ``cout << node->data; ``        ``node = node->next; ``    ``} ``    ``cout<next = newNode(9); ``    ``head->next->next = newNode(9); ``    ``head->next->next->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`

## C

 `// 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;``}` `/* 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``void` `printList(Node *node)``{``    ``while` `(node != NULL)``    ``{``        ``printf``(``"%d"``, node->data);``        ``node = node->next;``    ``}``    ``printf``(``"\n"``);``}` `/* Driver program to test above function */``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

 `// 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` `(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

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

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

 ``

Output
```List is 1999

Resultant list is 2000```

Time Complexity: O(n), Here n is the number of nodes in the linked list.
Auxiliary Space: O(1), As constant extra space is used.

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

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

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

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

 ``

Output
```List is 1999

Resultant list is 2000```

Time Complexity: O(n), Here n is the number of nodes in the linked list.
Auxiliary Space: O(n),The extra space is used in recursion call stack.

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;``}` `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``(``"\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;``}``// This code is contribute by 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;``}` `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.`

## Python3

 `# Recursive Python 3 program to add 1 to a linked list``class` `GFG :``    ``# Linked list node``    ``class` `Node :``        ``data ``=` `0``        ``next` `=` `None``    ``# Function to create a new node with given data``    ``@staticmethod``    ``def`  `newNode( data) :``        ``new_node ``=` `GFG.Node()``        ``new_node.data ``=` `data``        ``new_node.``next` `=` `None``        ``return` `new_node``    ``@staticmethod``    ``def`  `addOne( head) :``        ``# Return head of list after adding one``        ``ln ``=` `head``        ``if` `(head.``next` `=``=` `None``) :``            ``head.data ``+``=` `1``            ``return` `head``        ``t ``=` `head``        ``prev ``=` `0``        ``while` `(t.``next` `!``=` `None``) :``            ``if` `(t.data !``=` `9``) :``                ``ln ``=` `t``            ``t ``=` `t.``next``        ``if` `(t.data ``=``=` `9` `and` `ln !``=` `None``) :``            ``t ``=` `ln``            ``t.data ``+``=` `1``            ``t ``=` `t.``next``            ``while` `(t !``=` `None``) :``                ``t.data ``=` `0``                ``t ``=` `t.``next``        ``else` `:``            ``t.data ``+``=` `1``        ``return` `head``    ``# A utility function to print a linked list``    ``@staticmethod``    ``def` `printList( node) :``        ``while` `(node !``=` `None``) :``            ``print``(node.data, end ``=``"")``            ``node ``=` `node.``next``        ``print``()``    ``# Driver code``    ``@staticmethod``    ``def` `main( args) :``        ``head ``=` `GFG.newNode(``1``)``        ``head.``next` `=` `GFG.newNode(``9``)``        ``head.``next``.``next` `=` `GFG.newNode(``9``)``        ``head.``next``.``next``.``next` `=` `GFG.newNode(``9``)``        ``print``(``"List is "``, end ``=``"")``        ``GFG.printList(head)``        ``head ``=` `GFG.addOne(head)``        ``print``()``        ``print``(``"Resultant list is "``, end ``=``"")``        ``GFG.printList(head)``    ` `if` `__name__``=``=``"__main__"``:``    ``GFG.main([])``    ` `    ``# This code is contributed by mukulsomukesh.`

## 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;``  ``}` `  ``public` `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;` `    ``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``  ``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 Abhijeet Kumar(abhijeet19403) */`

## Javascript

 ``

Output
```List is 1999

Resultant list is 2000```

Time Complexity: O(n), Here n is the number of nodes in the linked list.
Auxiliary Space: O(1), As constant extra space is used.

The easy way to add 1 in number represented by linked list.

The Approach:

we first traverse over lined list and get the number that there in linked list simple while loop code and then add one to that number and then convert that number to linked list by simple while loop of(%10 and /10).

## C++

 `#include ``#include``using` `namespace` `std;` `/* Linked list Node */``struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``};` `Node* newNode(``int` `data)``{``    ``Node* new_node = (Node*)``malloc``(``sizeof``(Node));``    ``new_node->data = data;``    ``new_node->next = NULL;``    ``return` `new_node;``}` `/* Function to insert a node at the``beginning of the Singly Linked List */``void` `push(Node** head_ref, ``int` `new_data)``{``    ``/* allocate node */``    ``Node* new_node = newNode(new_data);``    ``/* link the old list of the new node */``    ``new_node->next = (*head_ref);``    ``/* move the head to point to the new node */``    ``(*head_ref) = new_node;``}` `void` `printList(Node* n)``{``    ``while` `(n) {``        ``cout << n->data << ``" "``;``        ``n = n->next;``    ``}``    ``cout << endl;``}``// function working on addition.``Node* addTwoLists(Node*first){``  ``int` `num1=0;``  ``// get the number.``   ``while``(first->next!=NULL){``     ``num1 +=first->data;``     ``num1*=10;``     ``first=first->next;``   ``}``   ``num1+=first->data;``   ``// add one to it.``   ``int` `num2=num1+1;``   ``Node* temp=NULL;``   ``//Node* result=temp;``  ``// made the linked list form it.``   ``while``(num2!=0){``     ``int` `last=num2%10;``     ``push(&temp,last);``     ``num2=num2/10;``   ``}``  ``// return the list``   ``return` `temp;``}``int` `main() {``  ``Node* first = NULL;``  ``push(&first, 6);``  ``push(&first, 4);``  ``push(&first, 9);``  ``push(&first, 5);``  ``push(&first, 7);``  ``Node* ans = addTwoLists(first);``  ``cout << ``"Sum is of first : "``;``  ``printList(ans);``  ``Node* second=NULL;``  ``push(&second, 9);``  ``push(&second, 9);``  ``push(&second, 9);``  ``push(&second, 1);``  ``cout << ``"Sum is of second : "``;``  ``Node* res=addTwoLists(second);``  ``printList(res);``  ``return` `0;``}`

## Java

 `// Java code ``import` `java.util.*;` `/* Linked list Node */``class` `Node {``  ``int` `data;``  ``Node next;` `  ``Node(``int` `d) {``    ``data = d;``    ``next = ``null``;``  ``}``}` `class` `AddLinkedList``{``  ` `  ``// Function to insert a node at the``  ``// beginning of the Singly Linked List``  ``static` `Node push(Node head_ref, ``int` `new_data)``  ``{``    ` `    ``/* allocate node */``    ``Node new_node = ``new` `Node(new_data);` `    ``/* link the old list of the new node */``    ``new_node.next = head_ref;` `    ``/* move the head to point to the new node */``    ``head_ref = new_node;``    ``return` `head_ref;``  ``}` `  ``static` `void` `printList(Node n) {``    ``while` `(n != ``null``) {``      ``System.out.print(n.data + ``" "``);``      ``n = n.next;``    ``}``    ``System.out.println();``  ``}` `  ``// function working on addition.``  ``static` `Node addTwoLists(Node first) {``    ``int` `num1 = ``0``;``    ` `    ``// get the number.``    ``while` `(first.next != ``null``) {``      ``num1 += first.data;``      ``num1 *= ``10``;``      ``first = first.next;``    ``}``    ``num1 += first.data;``    ` `    ``// add one to it.``    ``int` `num2 = num1 + ``1``;``    ``Node temp = ``null``;``    ` `    ``// Node* result=temp;``    ``// made the linked list form it.``    ``while` `(num2 != ``0``) {``      ``int` `last = num2 % ``10``;``      ``temp = push(temp, last);``      ``num2 = num2 / ``10``;``    ``}``    ` `    ``// return the list``    ``return` `temp;``  ``}` `  ``public` `static` `void` `main(String[] args) {``    ``Node first = ``null``;``    ``first = push(first, ``6``);``    ``first = push(first, ``4``);``    ``first = push(first, ``9``);``    ``first = push(first, ``5``);``    ``first = push(first, ``7``);``    ``Node ans = addTwoLists(first);``    ``System.out.print(``"Sum is of first : "``);``    ``printList(ans);``    ``Node second = ``null``;``    ``second = push(second, ``9``);``    ``second = push(second, ``9``);``    ``second = push(second, ``9``);``    ``second = push(second, ``1``);``    ``System.out.print(``"Sum is of second : "``);``    ``Node res = addTwoLists(second);``    ``printList(res);``  ``}``}` `// This code is contributed by Utkarsh.`

## Python3

 `# Linked list Node``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.``next` `=` `None` `# Function to insert a node at the beginning of the Singly Linked List``def` `push(head_ref, new_data):``  ` `    ``# Allocate new node``    ``new_node ``=` `Node(new_data)``    ` `    ``# Link the old list of the new node``    ``new_node.``next` `=` `head_ref``    ` `    ``# Move the head to point to the new node``    ``head_ref ``=` `new_node``    ``return` `head_ref` `def` `printList(n):``    ``while` `n:``        ``print``(n.data, end``=``" "``)``        ``n ``=` `n.``next``    ``print``()` `# Function working on addition.``def` `addTwoLists(first):``    ``num1 ``=` `0``    ``# Get the number``    ``while` `first.``next` `!``=` `None``:``        ``num1 ``+``=` `first.data``        ``num1 ``*``=` `10``        ``first ``=` `first.``next``    ``num1 ``+``=` `first.data``    ` `    ``# Add one to it``    ``num2 ``=` `num1 ``+` `1``    ``temp ``=` `None``    ` `    ``# Made the linked list form it``    ``while` `num2 !``=` `0``:``        ``last ``=` `num2 ``%` `10``        ``temp ``=` `push(temp, last)``        ``num2 ``/``/``=` `10``        ` `    ``# Return the list``    ``return` `temp` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``first ``=` `None``    ``first ``=` `push(first, ``6``)``    ``first ``=` `push(first, ``4``)``    ``first ``=` `push(first, ``9``)``    ``first ``=` `push(first, ``5``)``    ``first ``=` `push(first, ``7``)` `    ``ans ``=` `addTwoLists(first)``    ``print``(``"Sum is of first: "``, end``=``"")``    ``printList(ans)` `    ``second ``=` `None``    ``second ``=` `push(second, ``9``)``    ``second ``=` `push(second, ``9``)``    ``second ``=` `push(second, ``9``)``    ``second ``=` `push(second, ``1``)` `    ``res ``=` `addTwoLists(second)``    ``print``(``"Sum is of second: "``, end``=``"")``    ``printList(res)`

## C#

 `// C# program of the above approach``using` `System;` `/* Linked list Node */``class` `Node {``  ``public` `int` `data;``  ``public` `Node next;` `  ``public` `Node(``int` `d) {``    ``data = d;``    ``next = ``null``;``  ``}``}` `class` `AddLinkedList {` `  ``// Function to insert a node at the``  ``// beginning of the Singly Linked List``  ``static` `Node push(Node head_ref, ``int` `new_data) {``    ``/* allocate node */``    ``Node new_node = ``new` `Node(new_data);` `    ``/* link the old list of the new node */``    ``new_node.next = head_ref;` `    ``/* move the head to point to the new node */``    ``head_ref = new_node;``    ``return` `head_ref;``  ``}` `  ``static` `void` `printList(Node n) {``    ``while` `(n != ``null``) {``      ``Console.Write(n.data + ``" "``);``      ``n = n.next;``    ``}``    ``Console.WriteLine();``  ``}` `  ``// function working on addition.``  ``static` `Node addTwoLists(Node first) {``    ``int` `num1 = 0;` `    ``// get the number.``    ``while` `(first.next != ``null``) {``      ``num1 += first.data;``      ``num1 *= 10;``      ``first = first.next;``    ``}``    ``num1 += first.data;` `    ``// add one to it.``    ``int` `num2 = num1 + 1;``    ``Node temp = ``null``;` `    ``// Node* result=temp;``    ``// made the linked list form it.``    ``while` `(num2 != 0) {``      ``int` `last = num2 % 10;``      ``temp = push(temp, last);``      ``num2 = num2 / 10;``    ``}` `    ``// return the list``    ``return` `temp;``  ``}` `  ``static` `void` `Main(``string``[] args) {``    ``Node first = ``null``;``    ``first = push(first, 6);``    ``first = push(first, 4);``    ``first = push(first, 9);``    ``first = push(first, 5);``    ``first = push(first, 7);``    ``Node ans = addTwoLists(first);``    ``Console.Write(``"Sum is of first : "``);``    ``printList(ans);``    ``Node second = ``null``;``    ``second = push(second, 9);``    ``second = push(second, 9);``    ``second = push(second, 9);``    ``second = push(second, 1);``    ``Console.Write(``"Sum is of second : "``);``    ``Node res = addTwoLists(second);``    ``printList(res);``  ``}``}` `// This code is contributed by Pushpesh Raj.`

## Javascript

 `// Linked list Node``class Node {``  ``constructor(data) {``    ``this``.data = data;``    ``this``.next = ``null``;``  ``}``}` `// Function to insert a node at the beginning of the Singly Linked List``function` `push(head_ref, new_data) {``  ``// Allocate new node``  ``const new_node = ``new` `Node(new_data);` `  ``// Link the old list of the new node``  ``new_node.next = head_ref;` `  ``// Move the head to point to the new node``  ``head_ref = new_node;``  ``return` `head_ref;``}` `function` `printList(n) {``  ``let ans=``""``;``  ``while` `(n) {``    ``ans = ans + n.data+``" "``;``    ``n = n.next;``  ``}``  ``console.log(ans);``}` `// Function working on addition.``function` `addTwoLists(first) {``  ``let num1 = 0;``  ``// Get the number``  ``while` `(first.next != ``null``) {``    ``num1 += first.data;``    ``num1 *= 10;``    ``first = first.next;``  ``}``  ``num1 += first.data;` `  ``// Add one to it``  ``let num2 = num1 + 1;``  ``let temp = ``null``;` `  ``// Made the linked list form it``  ``while` `(num2 != 0) {``    ``const last = num2 % 10;``    ``temp = push(temp, last);``    ``num2 = Math.floor(num2 / 10);``  ``}` `  ``// Return the list``  ``return` `temp;``}` `// Driver code``let first = ``null``;``first = push(first, 6);``first = push(first, 4);``first = push(first, 9);``first = push(first, 5);``first = push(first, 7);` `let ans = addTwoLists(first);``console.log(``"Sum is of first: "``);``printList(ans);` `let second = ``null``;``second = push(second, 9);``second = push(second, 9);``second = push(second, 9);``second = push(second, 1);` `let res = addTwoLists(second);``console.log(``"Sum is of second: "``);``printList(res);`

Time Complexity: O(n), Here n is the number of nodes in the linked list.
Auxiliary Space: O(n), Need one temporary linked list to store result.

Previous
Next