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

Example:

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

Input: List1: 7->5->9->4->6  // represents number 64957
List2: 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.

Approach: Traverse both lists and One by one pick nodes of both lists and add the values. If the 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.

Below is the implementation of this approach.

## C++

 `// C++ program to add two numbers  ` `// represented by 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 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 off the new node */` `    ``new_node->next = (*head_ref);  ` ` `  `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node;  ` `}  ` ` `  `/* Adds contents of two linked lists and  ` `return the head node of resultant list */` `Node* addTwoLists (Node* first, Node* second)  ` `{  ` `    ``Node* res = NULL; ``// res is head node of the resultant list  ` `    ``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;  ` `             `  `        ``// If this is not the first  ` `        ``// node then connect it to the rest. ` `        ``else`   `            ``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(Node *node)  ` `{  ` `    ``while``(node != NULL)  ` `    ``{  ` `        ``cout << node->data << ``" "``;  ` `        ``node = node->next;  ` `    ``}  ` `    ``cout<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);  ` `    ``cout<<``"Second List is "``;  ` `    ``printList(second);  ` ` `  `    ``// Add the two lists and see result  ` `    ``res = addTwoLists(first, second);  ` `    ``cout<<``"Resultant list is "``;  ` `    ``printList(res);  ` ` `  `return` `0;  ` `}  ` ` `  `// This code is contributed by rathbhupendra `

## C

 `#include ` `#include ` ` `  `/* Linked list node */` `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 Singly 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 */` `    ``new_node->next = (*head_ref); ` ` `  `    ``/* move the head to point to the new node */` `    ``(*head_ref)    = new_node; ` `} ` ` `  `/* Adds contents of two linked lists and return the head node of resultant list */` `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 ` `    ``res = addTwoLists(first, second); ` `    ``printf``(``"Resultant list is "``); ` `    ``printList(res); ` ` `  `   ``return` `0; ` `} `

## Java

 `// Java program to add two numbers represented by linked list ` ` `  `class` `LinkedList { ` ` `  `    ``static` `Node head1, head2; ` ` `  `    ``static` `class` `Node { ` ` `  `        ``int` `data; ` `        ``Node next; ` ` `  `        ``Node(``int` `d) { ` `            ``data = d; ` `            ``next = ``null``; ` `        ``} ` `    ``} ` ` `  `    ``/* Adds contents of two linked lists and return the head node of resultant list */` `    ``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 */` ` `  `    ``void` `printList(Node head) { ` `        ``while` `(head != ``null``) { ` `            ``System.out.print(head.data + ``" "``); ` `            ``head = head.next; ` `        ``} ` `        ``System.out.println(``""``); ` `    ``} ` ` `  `    ``public` `static` `void` `main(String[] args) { ` `        ``LinkedList list = ``new` `LinkedList(); ` ` `  `        ``// creating first list ` `        ``list.head1 = ``new` `Node(``7``); ` `        ``list.head1.next = ``new` `Node(``5``); ` `        ``list.head1.next.next = ``new` `Node(``9``); ` `        ``list.head1.next.next.next = ``new` `Node(``4``); ` `        ``list.head1.next.next.next.next = ``new` `Node(``6``); ` `        ``System.out.print(``"First List is "``); ` `        ``list.printList(head1); ` ` `  `        ``// creating seconnd list ` `        ``list.head2 = ``new` `Node(``8``); ` `        ``list.head2.next = ``new` `Node(``4``); ` `        ``System.out.print(``"Second List is "``); ` `        ``list.printList(head2); ` ` `  `        ``// add the two lists and see the result ` `        ``Node rs = list.addTwoLists(head1, head2); ` `        ``System.out.print(``"Resultant List is "``); ` `        ``list.printList(rs); ` `    ``} ` `} ` ` `  `// this code has been contributed by Mayank Jaiswal `

## Python

 `# Python program to add two numbers represented by linked list ` ` `  `# Node class ` `class` `Node: ` ` `  `    ``# Constructor to initialize the node object ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None` ` `  `class` `LinkedList: ` ` `  `    ``# Function to initialize head ` `    ``def` `__init__(``self``): ` `        ``self``.head ``=` `None` ` `  `    ``# Function to insert a new node at the beginning ` `    ``def` `push(``self``, new_data): ` `        ``new_node ``=` `Node(new_data) ` `        ``new_node.``next` `=` `self``.head ` `        ``self``.head ``=` `new_node ` ` `  `    ``# Add contents of two linked lists and return the head ` `    ``# node of resultant list ` `    ``def` `addTwoLists(``self``, first, second): ` `        ``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 ` `            ``if` `self``.head ``is` `None``: ` `                ``self``.head ``=` `temp ` `            ``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) ` ` `  `    ``# Utility function to print the linked LinkedList ` `    ``def` `printList(``self``): ` `        ``temp ``=` `self``.head ` `        ``while``(temp): ` `            ``print` `temp.data, ` `            ``temp ``=` `temp.``next` ` `  `# Driver program to test above function ` `first ``=` `LinkedList() ` `second ``=` `LinkedList() ` ` `  `# 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 ` `res ``=` `LinkedList() ` `res.addTwoLists(first.head, second.head) ` `print` `"\nResultant list is "``, ` `res.printList() ` ` `  `# This code is contributed by Nikhil Kumar Singh(nickzuck_007) `

## C#

 `// C# program to add two numbers  ` `// represented by linked list ` `using` `System; ` ` `  `public` `class` `LinkedList ` `{ ` ` `  `    ``Node head1, head2; ` ` `  `    ``public` `class` `Node  ` `    ``{ ` `        ``public` `int` `data; ` `        ``public` `Node next; ` ` `  `        ``public` `Node(``int` `d)  ` `        ``{ ` `            ``data = d; ` `            ``next = ``null``; ` `        ``} ` `    ``} ` ` `  `    ``/* Adds contents of two linked lists  ` `    ``and return the head node of resultant list */` `    ``Node addTwoLists(Node first, Node second) ` `    ``{ ` `        ``// res is head node of the resultant list ` `        ``Node res = ``null``;  ` `        ``Node prev = ``null``; ` `        ``Node temp = ``null``; ` `        ``int` `carry = 0, sum; ` ` `  `        ``// while both lists exist ` `        ``while` `(first != ``null` `|| second != ``null``)  ` `        ``{ ` `            ``// 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; ` `            ``}  ` `             `  `            ``// If this is not the first ` `            ``// node then connect it to the rest. ` `            ``else`  `            ``{ ` `                ``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 */` ` `  `    ``void` `printList(Node head)  ` `    ``{ ` `        ``while` `(head != ``null``)  ` `        ``{ ` `            ``Console.Write(head.data + ``" "``); ` `            ``head = head.next; ` `        ``} ` `    ``Console.WriteLine(``""``); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``LinkedList list = ``new` `LinkedList(); ` ` `  `        ``// creating first list ` `        ``list.head1 = ``new` `Node(7); ` `        ``list.head1.next = ``new` `Node(5); ` `        ``list.head1.next.next = ``new` `Node(9); ` `        ``list.head1.next.next.next = ``new` `Node(4); ` `        ``list.head1.next.next.next.next = ``new` `Node(6); ` `        ``Console.Write(``"First List is "``); ` `        ``list.printList(list.head1); ` ` `  `        ``// creating seconnd list ` `        ``list.head2 = ``new` `Node(8); ` `        ``list.head2.next = ``new` `Node(4); ` `        ``Console.Write(``"Second List is "``); ` `        ``list.printList(list.head2); ` ` `  `        ``// add the two lists and see the result ` `        ``Node rs = list.addTwoLists(list.head1, list.head2); ` `        ``Console.Write(``"Resultant List is "``); ` `        ``list.printList(rs); ` `    ``} ` `} ` ` `  `// This code contributed by Rajput-Ji `

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.

My Personal Notes arrow_drop_up

Article Tags :

11

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.