Given two numbers represented by two lists, write a function that returns sum list. The sum list is list representation of addition of two input numbers.

Example 1

```Input:
First List: 5->6->3  // represents number 365
Second List: 8->4->2 //  represents number 248
Output
Resultant list: 3->1->6  // represents number 613
```

Example 2

```Input:
First List: 7->5->9->4->6  // represents number 64957
Second List: 8->4 //  represents number 48
Output
Resultant list: 5->0->0->5->6  // represents number 65005
```

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

Solution
Traverse both lists. One by one pick nodes of both lists and add the values. If sum is more than 10 then make carry as 1 and reduce sum. If one list has more elements than the other then consider remaining values of this list as 0. Following is the implementation of this approach.

## C

```#include<stdio.h>
#include<stdlib.h>

struct Node
{
int data;
struct Node* next;
};

/* Function to create a new node with given data */
struct Node *newNode(int data)
{
struct Node *new_node = (struct Node *) malloc(sizeof(struct Node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}

/* Function to insert a node at the beginning of the Doubly Linked List */
void push(struct Node** head_ref, int new_data)
{
/* allocate node */
struct Node* new_node = newNode(new_data);

/* link the old list off the new node */

/* move the head to point to the new node */
}

struct Node* addTwoLists (struct Node* first, struct Node* second)
{
struct Node* res = NULL; // res is head node of the resultant list
struct Node *temp, *prev = NULL;
int carry = 0, sum;

while (first != NULL || second != 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 first list (if there is a next digit)
// (ii) Next digit of second list (if there is a next digit)
sum = carry + (first? first->data: 0) + (second? second->data: 0);

// 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
temp = newNode(sum);

// if this is the first node then set it as head of the resultant list
if(res == NULL)
res = temp;
else // If this is not the first node then connect it to the rest.
prev->next = temp;

// Set prev for next insertion
prev  = temp;

// Move first and second pointers to next nodes
if (first) first = first->next;
if (second) second = second->next;
}

if (carry > 0)
temp->next = newNode(carry);

// return head of the resultant list
return res;
}

// A utility function to print a linked list
void printList(struct Node *node)
{
while(node != NULL)
{
printf("%d ", node->data);
node = node->next;
}
printf("\n");
}

/* Driver program to test above function */
int main(void)
{
struct Node* res = NULL;
struct Node* first = NULL;
struct Node* second = NULL;

// create first list 7->5->9->4->6
push(&first, 6);
push(&first, 4);
push(&first, 9);
push(&first, 5);
push(&first, 7);
printf("First List is ");
printList(first);

// create second list 8->4
push(&second, 4);
push(&second, 8);
printf("Second List is ");
printList(second);

// Add the two lists and see result
printf("Resultant list is ");
printList(res);

return 0;
}
```

## Java

```// Java program to delete a given node in linked list under given constraints

static class Node {

int data;
Node next;

Node(int d) {
data = d;
next = null;
}
}

Node addTwoLists(Node first, Node second) {
Node res = null; // res is head node of the resultant list
Node prev = null;
Node temp = null;
int carry = 0, sum;

while (first != null || second != 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 first list (if there is a next digit)
// (ii) Next digit of second list (if there is a next digit)
sum = carry + (first != null ? first.data : 0)
+ (second != null ? second.data : 0);

// 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
temp = new Node(sum);

// if this is the first node then set it as head of
// the resultant list
if (res == null) {
res = temp;
} else // If this is not the first node then connect it to the rest.
{
prev.next = temp;
}

// Set prev for next insertion
prev = temp;

// Move first and second pointers to next nodes
if (first != null) {
first = first.next;
}
if (second != null) {
second = second.next;
}
}

if (carry > 0) {
temp.next = new Node(carry);
}

// return head of the resultant list
return res;
}
/* Utility function to print a linked list */

}
System.out.println("");
}

public static void main(String[] args) {

// creating first list
System.out.print("First List is ");

// creating seconnd list
System.out.print("Second List is ");

// add the two lists and see the result
System.out.print("Resultant List is ");
list.printList(rs);
}
}

// this code has been contributed by Mayank Jaiswal

```

## Python

```

# Node class
class Node:

# Constructor to initialize the node object
def __init__(self, data):
self.data = data
self.next = None

def __init__(self):

# Function to insert a new node at the beginning
def push(self, new_data):
new_node = Node(new_data)

# node of resultant list
prev = None
temp = None
carry = 0

# While both list exists
while(first is not None or second is not None):

# Calculate the value of next digit in
# resultant list
# The next digit is sum of following things
# (i) Carry
# (ii) Next digit of first list (if ther is a
# next digit)
# (iii) Next digit of second list ( if there
# is a next digit)
fdata = 0 if first is None else first.data
sdata = 0 if second is None else second.data
Sum = carry + fdata + sdata

# update carry for next calculation
carry = 1 if Sum >= 10 else 0

# update sum if it is greater than 10
Sum = Sum if Sum < 10 else Sum % 10

# Create a new node with sum as data
temp = Node(Sum)

# if this is the first node then set it as head
# of resultant list
else :
prev.next = temp

# Set prev for next insertion
prev = temp

# Move first and second pointers to next nodes
if first is not None:
first = first.next
if second is not None:
second = second.next

if carry > 0:
temp.next = Node(carry)

def printList(self):
while(temp):
print temp.data,
temp = temp.next

# Driver program to test above function

# Create first list
first.push(6)
first.push(4)
first.push(9)
first.push(5)
first.push(7)
print "First List is ",
first.printList()

# Create second list
second.push(4)
second.push(8)
print "\nSecond List is ",
second.printList()

# Add the two lists and see result
print "\nResultant list is ",
res.printList()

# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

```

Output:

```  First List is 7 5 9 4 6
Second List is 8 4
Resultant list is 5 0 0 5 6```

Time Complexity: O(m + n) where m and n are number of nodes in first and second lists respectively.

Related Article : Add two numbers represented by linked lists | Set 2

Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem.

# GATE CS Corner    Company Wise Coding Practice

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