Related Articles
• Difficulty Level : Easy
• Last Updated : 10 Nov, 2020

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
Explanation: 365 + 248 = 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
Explanation: 64957 + 48 = 65005

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.

The steps are:

1. Traverse the two linked lists from start to end
3. If one of the list has reached the end then take 0 as its digit.
4. Continue it until both the lists end.
5. If the sum of two digits is greater than 9 then set carry as 1 and the current digit as sum % 10

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)``{` `    ``// res is head node of the resultant list``    ``Node* res = NULL;``    ``Node *temp, *prev = 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 ? 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 << endl;``}` `/* Driver code */``int` `main(``void``)``{``    ``Node* res = NULL;``    ``Node* first = NULL;``    ``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);``    ``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)``{` `    ``// res is head node of the resultant list``    ``struct` `Node* res = NULL;``    ``struct` `Node *temp, *prev = 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 ? 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(``struct` `Node* node)``{``    ``while` `(node != NULL) {``        ``printf``(``"%d "``, node->data);``        ``node = node->next;``    ``}``    ``printf``(``"\n"``);``}` `/* Driver code */``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)``    ``{``        ``// 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``) {``            ``System.out.print(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``System.out.println(``""``);``    ``}` `    ``// 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``);``        ``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 code``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
```

Complexity Analysis:

• Time Complexity: O(m + n), where m and n are number of nodes in first and second lists respectively.
The lists needs to be traversed only once.
• Space Complexity: O(m + n).
A temporary linked list is needed to store the output number