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)

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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 C++ implementation of above steps.

```// C++ program to add 1 to a linked list
#include<bits/stdc++.h>

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 * prev   = NULL;
Node * next;
while (current != NULL)
{
next  = current->next;
current->next = prev;
prev = current;
current = next;
}
return prev;
}

node of resultant list */
{
// res is head node of the resultant list
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)

// update carry for next calulation
carry = (sum >= 10)? 1 : 0;

// update sum if it is greater than 10
sum = sum % 10;

// Create a new node with sum as data

// Move head and second pointers to next nodes
}

// 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().
{

// Add one from left to right of reversed
// list

// Reverse the modified list
}

// 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)
{

printf("List is ");

printf("\nResultant list is ");

return 0;
}
```

Output:

```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 C++ implementation of recursive solution.

```// Recursive C++ program to add 1 to a linked list
#include<bits/stdc++.h>

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.
{
// If linked list is empty, then
// return carry
return 1;

// Add carry returned be next node call

// Update data and return new carry
return (res) / 10;
}

// This function mainly uses addWithCarry().
{

// 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;
return newNode; // New node becomes head now
}

}

// 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)
{

printf("List is ");

printf("\nResultant list is ");

return 0;
}
```

Output:

```List is 1999

Resultant list is 2000```

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
2.5 Average Difficulty : 2.5/5.0
Based on 80 vote(s)