Open in App
Not now

• Difficulty Level : Easy
• Last Updated : 15 Mar, 2023

Given two numbers represented by two lists, write a function that returns the sum in the form of a linked list.

Example:

Input:
List1: 5->6->3 // represents number 563
List2: 8->4->2 // represents number 842
Output:
Resultant list: 1->4->0->5 // represents number 1405
Explanation: 563 + 842 = 1405

Input:
List1: 7->5->9->4->6 // represents number 75946
List2: 8->4 // represents number 84
Output:
Resultant list: 7->6->0->3->0// represents number 76030
Explanation: 75946+84=76030

Traverse both lists to the end and add preceding zeros in the list with lesser digits. Then call a recursive function on the start nodes of both lists which calls itself for the next nodes of both lists till it gets to the end. This function creates a node for the sum of the current digits and returns the carry.

Follow the steps below to solve the problem:

• Traverse the two linked lists in order to add preceding zeros in case a list is having lesser digits than the other one.
• Start from the head node of both lists and call a recursive function for the next nodes.
• Continue it till the end of the lists.
• Creates a node for current digits sum and returns the carry.

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 of 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 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` `        ``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;` `}`   `Node* reverse(Node* head)` `{` `    ``if` `(head == NULL || head->next == NULL)` `        ``return` `head;` `    ``// reverse the rest list and put the first element at the end ` `    ``Node* rest = reverse(head->next);` `    ``head->next->next = head;` `    ``head->next = NULL;` `    ``// fix the head pointer` `    ``return` `rest;` `}`   `// 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);`   `    ``// reverse both the lists` `    ``first = reverse(first);` `    ``second = reverse(second);` `    ``// Add the two lists` `    ``res = addTwoLists(first, second);`   `    ``// reverse the res to get the sum` `    ``res = reverse(res);` `    ``cout << ``"Resultant list is "``;` `    ``printList(res);` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to add two numbers` `// represented by linked list` `#include ` `#include `   `/* Linked list node */` `typedef` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `}Node;`   `/* Function to create a` `new node with given data */` `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;` `}`   `/* 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 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` `        ``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;` `}`   `Node* reverse(Node* head)` `{` `    ``if` `(head == NULL || head->next == NULL)` `        ``return` `head;` `    ``// reverse the rest list and put the first element at the end ` `    ``Node* rest = reverse(head->next);` `    ``head->next->next = head;` `    ``head->next = NULL;` `    ``// fix the head pointer` `    ``return` `rest;` `}`   `// 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* 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);` `    ``printf``(``"Second list is "``);` `    ``printList(second);`   `    ``// reverse both the lists` `    ``first = reverse(first);` `    ``second = reverse(second);` `    ``// Add the two lists` `    ``res = addTwoLists(first, second);`   `    ``// reverse the res to get the sum` `    ``res = reverse(res);` `       ``printf``(``"Resultant list is "``);` `    ``printList(res);` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## 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 prints it */` `    ``void` `addTwoLists(Node first, Node second) {` `        ``Node start1 = ``new` `Node(``0``);` `        ``start1.next = first;` `        ``Node start2 = ``new` `Node(``0``);` `        ``start2.next = second;`   `        ``addPrecedingZeros(start1, start2);` `        ``Node result = ``new` `Node(``0``);` `        ``if` `(sumTwoNodes(start1.next, start2.next, result) == ``1``) {` `            ``Node node = ``new` `Node(``1``);` `            ``node.next = result.next;` `            ``result.next = node;` `        ``}` `        ``printList(result.next);` `    ``}`   `    ``/* Adds lists and returns the carry */` `    ``private` `int` `sumTwoNodes(Node first, Node second, Node result) {` `        ``if` `(first == ``null``) {` `            ``return` `0``;` `        ``}` `        ``int` `number = first.data + second.data + sumTwoNodes(first.next, second.next, result);` `        ``Node node = ``new` `Node(number % ``10``);` `        ``node.next = result.next;` `        ``result.next = node;` `        ``return` `number / ``10``;` `    ``}`   `    ``/* Appends preceding zeros in case a list is having lesser nodes than the other one*/` `    ``private` `void` `addPrecedingZeros(Node start1, Node start2) {` `        ``Node next1 = start1.next;` `        ``Node next2 = start2.next;` `        ``while` `(next1 != ``null` `&& next2 != ``null``) {` `            ``next1 = next1.next;` `            ``next2 = next2.next;` `        ``}` `        ``if` `(next1 == ``null` `&& next2 != ``null``) {` `            ``while` `(next2 != ``null``) {` `                ``Node node = ``new` `Node(``0``);` `                ``node.next = start1.next;` `                ``start1.next = node;` `                ``next2 = next2.next;` `            ``}` `        ``} ``else` `if` `(next2 == ``null` `&& next1 != ``null``) {` `            ``while` `(next1 != ``null``) {` `                ``Node node = ``new` `Node(``0``);` `                ``node.next = start2.next;` `                ``start2.next = node;` `                ``next1 = next1.next;` `            ``}` `        ``}` `    ``}`   `    ``/* 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 second list` `        ``list.head2 = ``new` `Node(``8``);` `        ``list.head2.next = ``new` `Node(``4``);` `        ``System.out.print(``"Second list is "``);` `        ``list.printList(head2);`   `        ``System.out.print(``"Resultant list is "``);` `        ``// add the two lists and see the result` `        ``list.addTwoLists(head1, head2);` `    ``}`   `    ``// this code is contributed by *Saurabh321Gupta*` `}`

## Python3

 `class` `Solution:` `    ``# Function to reverse a list` `    ``def` `reverse(``self``, head):` `        ``if` `head ``is` `None` `or` `head.``next` `is` `None``:` `            ``return` `head` `        ``prev ``=` `None` `        ``next` `=` `None` `        ``curr ``=` `head` `        ``while` `curr ``is` `not` `None``:` `            ``next` `=` `curr.``next` `            ``curr.``next` `=` `prev` `            ``prev ``=` `curr` `            ``curr ``=` `next` `        ``head ``=` `prev` `        ``return` `head`   `    ``# Function to add two numbers represented by linked list.`   `    ``def` `addTwoLists(``self``, first, second):`   `        ``# reverse the two lists` `        ``curr1 ``=` `self``.reverse(first)` `        ``curr2 ``=` `self``.reverse(second)`   `        ``# res is head node of the resultant list` `        ``sum` `=` `0` `        ``carry ``=` `0` `        ``res ``=` `None` `        ``prev ``=` `None`   `        ``# while both lists have atleast one node` `        ``while` `curr1 ``is` `not` `None` `or` `curr2 ``is` `not` `None``:`   `            ``# Calculating the sum of the last digits` `            ``sum` `=` `carry ``+` `(curr1.data ``if` `curr1 ``else` `0``) ``+` `\` `                ``(curr2.data ``if` `curr2 ``else` `0``)`   `            ``# update carry for next calculation` `            ``carry ``=` `(``1` `if` `sum` `>``=` `10` `else` `0``)`   `            ``# update sum if it is greater than 10` `            ``sum` `=` `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 the resultant list` `            ``if` `res ``is` `None``:` `                ``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` `curr1:` `                ``curr1 ``=` `curr1.``next` `            ``if` `curr2:` `                ``curr2 ``=` `curr2.``next`   `        ``# if carry from previous sums is remaining` `        ``if` `carry > ``0``:` `            ``temp.``next` `=` `Node(carry)`   `        ``# Reverse the resultant answer` `        ``ans ``=` `self``.reverse(res)` `        ``return` `ans`     `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.``next` `=` `None`     `class` `LinkedList:` `    ``def` `__init__(``self``):` `        ``self``.head ``=` `None` `        ``self``.tail ``=` `None`   `    ``def` `insert(``self``, val):` `        ``if` `self``.head ``is` `None``:` `            ``self``.head ``=` `Node(val)` `            ``self``.tail ``=` `self``.head` `        ``else``:` `            ``self``.tail.``next` `=` `Node(val)` `            ``self``.tail ``=` `self``.tail.``next`   `# Utility function to print the list`     `def` `printList(n):` `    ``while` `n:` `        ``print``(n.data, end ``=` `' '``)` `        ``n ``=` `n.``next` `    ``print``()`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr1 ``=` `[``7``, ``5``, ``9``, ``4``, ``6``]` `    ``LL1 ``=` `LinkedList()` `    ``for` `i ``in` `arr1:` `        ``LL1.insert(i)` `    ``print``(``"First list is"``, end ``=` `" "``)` `    ``printList(LL1.head)`   `    ``arr2 ``=` `[``8``, ``4``]` `    ``LL2 ``=` `LinkedList()` `    ``for` `i ``in` `arr2:` `        ``LL2.insert(i)` `    ``print``(``"Second list is"``, end ``=` `" "``)` `    ``printList(LL2.head)`   `    ``# Function Call` `    ``res ``=` `Solution().addTwoLists(LL1.head, LL2.head)` `    ``print``(``"Resultant list is"``, end ``=` `" "``)` `    ``printList(res)`   `# This code Contributed by Vaidehi Agarwal`

## C#

 `// C# program to add two numbers` `// represented by linked list` `using` `System;` `public` `class` `List {`   `    `  `    ``public` `class` `Node {`   `        ``public` `int` `data;` `        ``public` `Node next;`   `        ``public` `Node(``int` `d) {` `            ``data = d;` `            ``next = ``null``;` `        ``}` `    ``}` `    ``public` `static`  `Node head1, head2;`     `    ``/* Adds contents of two linked lists and prints it */` `    ``public` `void` `addTwoLists(Node first, Node second) {` `        ``Node start1 = ``new` `Node(0);` `        ``start1.next = first;` `        ``Node start2 = ``new` `Node(0);` `        ``start2.next = second;`   `        ``addPrecedingZeros(start1, start2);` `        ``Node result = ``new` `Node(0);` `        ``if` `(sumTwoNodes(start1.next, start2.next, result) == 1) {` `            ``Node node = ``new` `Node(1);` `            ``node.next = result.next;` `            ``result.next = node;` `        ``}` `        ``printList(result.next);` `    ``}`   `    ``/* Adds lists and returns the carry */` `    ``public`  `int` `sumTwoNodes(Node first, Node second, Node result) {` `        ``if` `(first == ``null``) {` `            ``return` `0;` `        ``}` `        ``int` `number = first.data + second.data + sumTwoNodes(first.next, second.next, result);` `        ``Node node = ``new` `Node(number % 10);` `        ``node.next = result.next;` `        ``result.next = node;` `        ``return` `number / 10;` `    ``}`   `    ``/*` `     ``* Appends preceding zeros in case a list is having lesser nodes than the other` `     ``* one` `     ``*/` `    ``public`  `void` `addPrecedingZeros(Node start1, Node start2) {` `        ``Node next1 = start1.next;` `        ``Node next2 = start2.next;` `        ``while` `(next1 != ``null` `&& next2 != ``null``) {` `            ``next1 = next1.next;` `            ``next2 = next2.next;` `        ``}` `        ``if` `(next1 == ``null` `&& next2 != ``null``) {` `            ``while` `(next2 != ``null``) {` `                ``Node node = ``new` `Node(0);` `                ``node.next = start1.next;` `                ``start1.next = node;` `                ``next2 = next2.next;` `            ``}` `        ``} ``else` `if` `(next2 == ``null` `&& next1 != ``null``) {` `            ``while` `(next1 != ``null``) {` `                ``Node node = ``new` `Node(0);` `                ``node.next = start2.next;` `                ``start2.next = node;` `                ``next1 = next1.next;` `            ``}` `        ``}` `    ``}`   `    ``/* Utility function to print a linked list */` `    ``public` `void` `printList(Node head) {` `        ``while` `(head != ``null``) {` `            ``Console.Write(head.data + ``" "``);` `            ``head = head.next;` `        ``}` `        ``Console.WriteLine(``""``);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args) {` `        ``List list = ``new` `List();`   `        ``// creating first list` `        ``Node head1 = ``new` `Node(7);` `        ``head1.next = ``new` `Node(5);` `        ``head1.next.next = ``new` `Node(9);` `        ``head1.next.next.next = ``new` `Node(4);` `        ``head1.next.next.next.next = ``new` `Node(6);` `        ``Console.Write(``"First list is "``);` `        ``list.printList(head1);`   `        ``// creating second list` `        ``Node head2 = ``new` `Node(8);` `        ``head2.next = ``new` `Node(4);` `        ``Console.Write(``"Second list is "``);` `        ``list.printList(head2);`   `        ``Console.Write(``"Resultant list is "``);` `        ``// add the two lists and see the result` `        ``list.addTwoLists(head1, head2);` `    ``}` `}`   `// This code is contributed by umadevi9616 `

## Javascript

 `class Solution {` `    ``// Function to reverse a list` `    ``reverse(head) {` `        ``if` `(head === ``null` `|| head.next === ``null``) {` `            ``return` `head;` `        ``}` `        ``let prev = ``null``;` `        ``let next = ``null``;` `        ``let curr = head;` `        ``while` `(curr !== ``null``) {` `            ``next = curr.next;` `            ``curr.next = prev;` `            ``prev = curr;` `            ``curr = next;` `        ``}` `        ``head = prev;` `        ``return` `head;` `    ``}`   `    ``// Function to add two numbers represented by linked list.` `    ``addTwoLists(first, second) {` `        ``// reverse the two lists` `        ``let curr1 = ``this``.reverse(first);` `        ``let curr2 = ``this``.reverse(second);`   `        ``// res is head node of the resultant list` `        ``let sum = 0;` `        ``let carry = 0;` `        ``let res = ``null``;` `        ``let prev = ``null``;`   `        ``// while both lists have at least one node` `        ``while` `(curr1 !== ``null` `|| curr2 !== ``null``) {` `            ``// Calculating the sum of the last digits` `            ``sum = carry + (curr1 ? curr1.data : 0) + (curr2 ? curr2.data : 0);`   `            ``// 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` `            ``let 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` `(curr1) {` `                ``curr1 = curr1.next;` `            ``}` `            ``if` `(curr2) {` `                ``curr2 = curr2.next;` `            ``}` `        ``}`   `        ``// if carry from previous sums is remaining` `        ``if` `(carry > 0) {` `            ``prev.next = ``new` `Node(carry);` `        ``}`   `        ``// Reverse the resultant answer` `        ``let ans = ``this``.reverse(res);` `        ``return` `ans;` `    ``}` `}`   `class Node {` `    ``constructor(data) {` `        ``this``.data = data;` `        ``this``.next = ``null``;` `    ``}` `}`   `class LinkedList {` `    ``constructor() {` `        ``this``.head = ``null``;` `        ``this``.tail = ``null``;` `    ``}`   `    ``insert(val) {` `        ``if` `(``this``.head === ``null``) {` `            ``this``.head = ``new` `Node(val);` `            ``this``.tail = ``this``.head;` `        ``} ``else` `{` `            ``this``.tail.next = ``new` `Node(val);` `            ``this``.tail = ``this``.tail.next;` `        ``}` `    ``}` `}`   `// Utility function to print the list` `function` `printList(n) {` `    ``while` `(n) {` `        ``console.log(n.data + ``" "``);` `        ``n = n.next;` `    ``}` `    ``console.log();` `}`   `// Driver Code` `let arr1 = [7, 5, 9, 4, 6];` `let LL1 = ``new` `LinkedList();` `for` `(let i = 0; i < arr1.length; i++) {` `    ``LL1.insert(arr1[i]);` `}` `console.log(``"First list is"``);` `printList(LL1.head);`   `let arr2 = [8, 4];` `let LL2 = ``new` `LinkedList();` `for` `(let i = 0; i < arr2.length; i++) {` `    ``LL2.insert(arr2[i]);` `}` `console.log(``"Second list is"``);` `printList(LL2.head);`   `// Function Call` `let res = ``new` `Solution().addTwoLists(LL1.head, LL2.head);` `console.log(``"Resultant list is"``, end = ``" "``)` `printList(res)`

Output

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

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

the easy way to add two number in linked list it can be this approach.

the approach: we have two linked list we just get it into number form if 1->2->3 then number is 123 using while loop and simple math here is how we get toward second last node of linked list and just add to number and multiply by 10. then at last node outside the while loop we add last node value and we get the number in linked list form yo number/integer.also do similar task for second linked list and then add both number and form a third number. and then we use again simple mathnand while loop to get number in last digit(by %10 and /10) and then push a node form every digit in new Linked list at the end here we have our new/resultant linked list.

## 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;` `}` `// function to linked list` `void` `printList(Node* n){` `    ``while` `(n) {` `        ``cout << n->data << ``" "``;` `        ``n = n->next;` `    ``}` `    ``cout << endl;` `}` `// function that work on addition operation.` `Node* addTwoLists(Node*first , Node*second){` `  ``int` `num1=0,num2=0;` `  ``//here we get num1 form first linked list.` `   ``while``(first->next!=NULL){` `     ``num1 +=first->data;` `     ``num1*=10;` `     ``first=first->next;` `   ``}` `   ``num1+=first->data;` `  ``// here we get num2 form second linked list.` `   ``while``(second->next!=NULL){` `     ``num2 +=second->data;` `     ``num2*=10;` `     ``second=second->next;` `   ``}` `   ``num2+=second->data;` `  ``// here we add both number.` `   ``int` `num3=num1+num2;` `   ``Node* temp=NULL;` `   ``//Node* result=temp;` `  ``// convert num3 into linked list.` `   ``while``(num3!=0){` `     ``int` `last=num3%10;` `     ``push(&temp,last);` `     ``num3=num3/10;` `   ``}` `  ``// finally return resultant linked list.` `   ``return` `temp;` `}` `int` `main() {` `  ``Node* first = NULL;` `  ``Node* second = NULL;` `      ``push(&first, 6);` `      ``push(&first, 4);` `      ``push(&first, 9);` `      ``push(&first, 5);` `      ``push(&first, 7);`   `      ``push(&second, 4);` `      ``push(&second, 8);`   `      ``Node* ans = addTwoLists(first, second);`   `      ``cout << ``"Sum is : "``;` `      ``printList(ans);` `  ``return` `0;` `}`

## Java

 `import` `java.util.*;`   `class` `Node {` `    ``int` `data;` `    ``Node next;`   `    ``Node(``int` `d)` `    ``{` `        ``data = d;` `        ``next = ``null``;` `    ``}` `}`   `class` `LinkedList {` `    ``Node head;`   `    ``LinkedList() { head = ``null``; }`   `    ``void` `push(``int` `new_data)` `    ``{` `        ``Node new_node = ``new` `Node(new_data);` `        ``new_node.next = head;` `        ``head = new_node;` `    ``}`   `    ``void` `printList()` `    ``{` `        ``Node n = head;` `        ``while` `(n != ``null``) {` `            ``System.out.print(n.data + ``" "``);` `            ``n = n.next;` `        ``}` `        ``System.out.println();` `    ``}` `}`   `class` `AddTwoLists {` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``LinkedList first = ``new` `LinkedList();` `        ``LinkedList second = ``new` `LinkedList();` `        ``first.push(``6``);` `        ``first.push(``4``);` `        ``first.push(``9``);` `        ``first.push(``5``);` `        ``first.push(``7``);`   `        ``second.push(``4``);` `        ``second.push(``8``);`   `        ``LinkedList ans = addTwoLists(first, second);`   `        ``System.out.print(``"Sum is : "``);` `        ``ans.printList();` `    ``}`   `    ``static` `LinkedList addTwoLists(LinkedList first,` `                                  ``LinkedList second)` `    ``{` `        ``int` `num1 = ``0``, num2 = ``0``;` `        ``while` `(first.head != ``null``) {` `            ``num1 = num1 * ``10` `+ first.head.data;` `            ``first.head = first.head.next;` `        ``}` `        ``while` `(second.head != ``null``) {` `            ``num2 = num2 * ``10` `+ second.head.data;` `            ``second.head = second.head.next;` `        ``}` `        ``int` `num3 = num1 + num2;` `        ``LinkedList temp = ``new` `LinkedList();` `        ``while` `(num3 != ``0``) {` `            ``int` `last = num3 % ``10``;` `            ``temp.push(last);` `            ``num3 = num3 / ``10``;` `        ``}` `        ``return` `temp;` `    ``}` `}`   `// This code is contributed by Tapesh(tapeshdua420)`

## Python3

 `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.``next` `=` `None` `        `  `class` `LinkedList:` `    ``def` `__init__(``self``):` `        ``self``.head ``=` `None` `    ``def` `push(``self``, new_data):` `        ``new_node ``=` `Node(new_data)` `        ``new_node.``next` `=` `self``.head` `        ``self``.head ``=` `new_node` `        `  `    ``def` `printList(``self``):` `        ``n ``=` `self``.head` `        ``while` `n:` `            ``print``(n.data, end``=``' '``)` `            ``n ``=` `n.``next` `        ``print``()`   `def` `addTwoLists(first, second):` `    ``num1, num2 ``=` `0``, ``0` `    ``while` `first.head:` `        ``num1 ``=` `num1``*``10` `+` `first.head.data` `        ``first.head ``=` `first.head.``next` `    ``while` `second.head:` `        ``num2 ``=` `num2``*``10` `+` `second.head.data` `        ``second.head ``=` `second.head.``next` `    ``num3 ``=` `num1 ``+` `num2` `    ``temp ``=` `LinkedList()` `    ``while` `num3:` `        ``last ``=` `num3 ``%` `10` `        ``temp.push(last)` `        ``num3 ``=` `num3 ``/``/` `10` `    ``return` `temp`   `if` `__name__ ``=``=` `'__main__'``:` `    ``first ``=` `LinkedList()` `    ``second ``=` `LinkedList()` `    ``first.push(``6``)` `    ``first.push(``4``)` `    ``first.push(``9``)` `    ``first.push(``5``)` `    ``first.push(``7``)`   `    ``second.push(``4``)` `    ``second.push(``8``)`   `    ``ans ``=` `addTwoLists(first, second)`   `    ``print``(``"Sum is : "``, end``=``' '``)` `    ``ans.printList()`

## C#

 `using` `System;`   `/* Linked list Node */` `public` `class` `Node {` `    ``public` `int` `data;` `    ``public` `Node next;`   `    ``public` `Node(``int` `data) {` `        ``this``.data = data;` `        ``this``.next = ``null``;` `    ``}` `}`   `public` `class` `Program {` `    ``/* Function to insert a node at the` `    ``beginning of the Singly Linked List */` `    ``static` `void` `push(``ref` `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;` `    ``}`   `    ``// function to linked list` `    ``static` `void` `printList(Node n) {` `        ``while` `(n != ``null``) {` `            ``Console.Write(n.data + ``" "``);` `            ``n = n.next;` `        ``}` `        ``Console.WriteLine();` `    ``}`   `    ``// function that work on addition operation.` `    ``static` `Node addTwoLists(Node first, Node second) {` `        ``int` `num1 = 0, num2 = 0;` `        ``//here we get num1 form first linked list.` `        ``while` `(first.next != ``null``) {` `            ``num1 += first.data;` `            ``num1 *= 10;` `            ``first = first.next;` `        ``}` `        ``num1 += first.data;` `        ``// here we get num2 form second linked list.` `        ``while` `(second.next != ``null``) {` `            ``num2 += second.data;` `            ``num2 *= 10;` `            ``second = second.next;` `        ``}` `        ``num2 += second.data;` `        ``// here we add both number.` `        ``int` `num3 = num1 + num2;` `        ``Node temp = ``null``;` `        ``// convert num3 into linked list.` `        ``while` `(num3 != 0) {` `            ``int` `last = num3 % 10;` `            ``push(``ref` `temp, last);` `            ``num3 = num3 / 10;` `        ``}` `        ``// finally return resultant linked list.` `        ``return` `temp;` `    ``}`   `    ``static` `void` `Main(``string``[] args) {` `        ``Node first = ``null``;` `        ``Node second = ``null``;` `        ``push(``ref` `first, 6);` `        ``push(``ref` `first, 4);` `        ``push(``ref` `first, 9);` `        ``push(``ref` `first, 5);` `        ``push(``ref` `first, 7);`   `        ``push(``ref` `second, 4);` `        ``push(``ref` `second, 8);`   `        ``Node ans = addTwoLists(first, second);`   `        ``Console.Write(``"Sum is : "``);` `        ``printList(ans);` `    ``}` `}`

## Javascript

 `// Javascript implementation of above approach`   `/* Linked list Node */` `class Node {` `    ``constructor(d) {` `    ``this``.data = d;` `    ``this``.next = ``null``;` `    ``}` `}`   `class LinkedList {` `    ``constructor() {` `    ``this``.head = ``null``;` `}` `/* Function to insert a node at the` `beginning of the Singly Linked List */` `push(new_data) {` `    ``/* allocate node */` `    ``let new_node = ``new` `Node(new_data);` `    ``/* link the old list of the new node */` `    ``new_node.next = ``this``.head;` `    ``/* move the head to point to the new node */` `    ``this``.head = new_node;` `}` `// function to linked list` `printList() {` `    ``let n = ``this``.head;` `        ``while` `(n !== ``null``) {` `        ``console.log(n.data + ``" "``);` `        ``n = n.next;` `    ``}` `    ``console.log();` `    ``}` `}`   `// function that work on addition operation.` `function` `addTwoLists(first, second) {` `    ``let num1 = 0,` `    ``num2 = 0;` `    ``//here we get num1 form first linked list.` `    ``while` `(first.head !== ``null``) {` `        ``num1 = num1 * 10 + first.head.data;` `        ``first.head = first.head.next;` `    ``}` `    ``// here we get num2 form second linked list.` `    ``while` `(second.head !== ``null``) {` `        ``num2 = num2 * 10 + second.head.data;` `        ``second.head = second.head.next;` `    ``}` `    ``// here we add both number.` `    ``let num3 = num1 + num2;` `    ``let temp = ``new` `LinkedList();` `    ``//Node* result=temp;` `  ``// convert num3 into linked list.` `    ``while` `(num3 !== 0) {` `        ``let last = num3 % 10;` `        ``temp.push(last);` `        ``num3 = Math.floor(num3 / 10);` `    ``}` `    `  `    ``// finally return resultant linked list.` `    ``return` `temp;` `}`   `let first = ``new` `LinkedList();` `let second = ``new` `LinkedList();` `first.push(6);` `first.push(4);` `first.push(9);` `first.push(5);` `first.push(7);`   `second.push(4);` `second.push(8);`   `let ans = addTwoLists(first, second);`   `console.log(``"Sum is : "``);` `ans.printList();`   `// this code is contributed by bhardwajji.`

Output

`Sum is : 7 6 0 3 0 `

Time Complexity: O(m + n)  where m and n are numbers of nodes in first and second lists respectively.
Auxiliary Space: O(m + n)  A temporary linked list is needed to store the output number.

Follow the steps to solve the problem:

• Create 3 stacks namely s1,s2,s3.
• Fill s1 with Nodes of list1 and fill s2 with nodes of list2.
• Fill s3 by creating new nodes and setting the data of new nodes to the sum of s1.top(), s2.top() and carry until list1 and list2 are empty.
• If the sum is greater than 9, set carry 1
• Else, set carry 0
• Create a Node(say prev) that will contain the head of the sum List.
• Link all the elements of s3 from top to bottom.
• Return prev node as the result.

Below is the implementation of above approach:

## C++

 `// C++ program to add two numbers represented by Linked` `// Lists using Stack` `#include ` `using` `namespace` `std;` `class` `Node {` `public``:` `    ``int` `data;` `    ``Node* next;` `};`   `Node* newnode(``int` `data)` `{` `    ``Node* x = ``new` `Node();` `    ``x->data = data;` `    ``return` `x;` `}`   `// function that returns the sum of two numbers represented` `// by linked lists` `Node* addTwoNumbers(Node* l1, Node* l2)` `{` `    ``Node* prev = NULL;` `    ``// Create 3 stacks` `    ``stack s1, s2, s3;` `    ``// Fill first stack with first List Elements` `    ``while` `(l1 != NULL) {` `        ``s1.push(l1);` `        ``l1 = l1->next;` `    ``}` `    ``// Fill second stack with second List Elements` `    ``while` `(l2 != NULL) {` `        ``s2.push(l2);` `        ``l2 = l2->next;` `    ``}` `    ``int` `carry = 0;` `    ``// Fill the third stack with the sum of first and second` `    ``// stack` `    ``while` `(!s1.empty() && !s2.empty()) {` `        ``int` `sum = s1.top()->data + s2.top()->data + carry;` `        ``Node* temp = newnode(sum % 10);` `        ``s3.push(temp);` `        ``if` `(sum > 9) {` `            ``carry = 1;` `        ``}` `        ``else` `{` `            ``carry = 0;` `        ``}` `        ``s1.pop();` `        ``s2.pop();` `    ``}` `    ``while` `(!s1.empty()) {` `        ``int` `sum = carry + s1.top()->data;` `        ``Node* temp = newnode(sum % 10);` `        ``s3.push(temp);` `        ``if` `(sum > 9) {` `            ``carry = 1;` `        ``}` `        ``else` `{` `            ``carry = 0;` `        ``}` `        ``s1.pop();` `    ``}` `    ``while` `(!s2.empty()) {` `        ``int` `sum = carry + s2.top()->data;` `        ``Node* temp = newnode(sum % 10);` `        ``s3.push(temp);` `        ``if` `(sum > 9) {` `            ``carry = 1;` `        ``}` `        ``else` `{` `            ``carry = 0;` `        ``}` `        ``s2.pop();` `    ``}` `    ``// If carry is still present create a new node with` `    ``// value 1 and push it to the third stack` `    ``if` `(carry == 1) {` `        ``Node* temp = newnode(1);` `        ``s3.push(temp);` `    ``}` `    ``// Link all the elements inside third stack with each` `    ``// other` `    ``if` `(!s3.empty())` `        ``prev = s3.top();` `    ``while` `(!s3.empty()) {` `        ``Node* temp = s3.top();` `        ``s3.pop();` `        ``if` `(s3.size() == 0) {` `            ``temp->next = NULL;` `        ``}` `        ``else` `{` `            ``temp->next = s3.top();` `        ``}` `    ``}` `    ``return` `prev;` `}`   `// utility functions` `// Function that displays the List` `void` `Display(Node* head)` `{` `    ``if` `(head == NULL) {` `        ``return``;` `    ``}` `    ``while` `(head->next != NULL) {` `        ``cout << head->data << ``" -> "``;` `        ``head = head->next;` `    ``}` `    ``cout << head->data << endl;` `}`   `// Function that adds element at the end of the Linked List` `void` `push(Node** head_ref, ``int` `d)` `{` `    ``Node* new_node = newnode(d);` `    ``new_node->next = NULL;` `    ``if` `(*head_ref == NULL) {` `        ``new_node->next = *head_ref;` `        ``*head_ref = new_node;` `        ``return``;` `    ``}` `    ``Node* last = *head_ref;` `    ``while` `(last->next != NULL && last != NULL) {` `        ``last = last->next;` `    ``}` `    ``last->next = new_node;` `    ``return``;` `}` `// Driver Program for above Functions` `int` `main()` `{` `    ``// Creating two lists` `    ``// first list = 9 -> 5 -> 0` `    ``// second List = 6 -> 7` `    ``Node* first = NULL;` `    ``Node* second = NULL;` `    ``Node* sum = NULL;` `    ``push(&first, 7);` `    ``push(&first, 5);` `    ``push(&first, 9);` `    ``push(&first, 4);` `    ``push(&first, 6);` `    ``push(&second, 8);` `    ``push(&second, 4);` `    ``cout << ``"First List : "``;` `    ``Display(first);` `    ``cout << ``"Second List : "``;` `    ``Display(second);` `    ``sum = addTwoNumbers(first, second);` `    ``cout << ``"Sum List : "``;` `    ``Display(sum);` `    ``return` `0;` `}`

## Java

 `// Java program to add two numbers represented by Linked` `// Lists using Stack` `import` `java.util.*;`   `class` `LinkedList {`   `    ``static` `Node head1, head2;`   `    ``static` `class` `Node {`   `        ``int` `data;` `        ``Node next;`   `        ``Node(``int` `d)` `        ``{` `            ``data = d;` `            ``next = ``null``;` `        ``}` `    ``}` `    ``// function that calculates and prints the sum of two` `    ``// numbers represented` `    ``// by linked lists` `    ``static` `void` `addTwoLists(Node l1, Node l2)` `    ``{` `        ``Node prev = ``null``;` `        ``// Create 3 stacks` `        ``Stack s1 = ``new` `Stack();` `        ``Stack s2 = ``new` `Stack();` `        ``Stack s3 = ``new` `Stack();` `        ``// Fill first stack with first List Elements` `        ``while` `(l1 != ``null``) {` `            ``s1.add(l1);` `            ``l1 = l1.next;` `        ``}` `        ``// Fill second stack with second List Elements` `        ``while` `(l2 != ``null``) {` `            ``s2.add(l2);` `            ``l2 = l2.next;` `        ``}` `        ``int` `carry = ``0``;` `        ``// Fill the third stack with the sum of first and` `        ``// second stack` `        ``while` `(!s1.isEmpty() && !s2.isEmpty()) {` `            ``int` `sum` `                ``= s1.peek().data + s2.peek().data + carry;` `            ``Node temp = ``new` `Node(sum % ``10``);` `            ``s3.add(temp);` `            ``if` `(sum > ``9``) {` `                ``carry = ``1``;` `            ``}` `            ``else` `{` `                ``carry = ``0``;` `            ``}` `            ``s1.pop();` `            ``s2.pop();` `        ``}` `        ``while` `(!s1.isEmpty()) {` `            ``int` `sum = carry + s1.peek().data;` `            ``Node temp = ``new` `Node(sum % ``10``);` `            ``s3.add(temp);` `            ``if` `(sum > ``9``) {` `                ``carry = ``1``;` `            ``}` `            ``else` `{` `                ``carry = ``0``;` `            ``}` `            ``s1.pop();` `        ``}` `        ``while` `(!s2.isEmpty()) {` `            ``int` `sum = carry + s2.peek().data;` `            ``Node temp = ``new` `Node(sum % ``10``);` `            ``s3.add(temp);` `            ``if` `(sum > ``9``) {` `                ``carry = ``1``;` `            ``}` `            ``else` `{` `                ``carry = ``0``;` `            ``}` `            ``s2.pop();` `        ``}` `        ``// If carry is still present create a new node with` `        ``// value 1 and push it to the third stack` `        ``if` `(carry == ``1``) {` `            ``Node temp = ``new` `Node(``1``);` `            ``s3.add(temp);` `        ``}` `        ``// Link all the elements inside third stack with` `        ``// each other` `        ``if` `(!s3.isEmpty())` `            ``prev = s3.peek();` `        ``while` `(!s3.isEmpty()) {` `            ``Node temp = s3.peek();` `            ``s3.pop();` `            ``if` `(s3.size() == ``0``) {` `                ``temp.next = ``null``;` `            ``}` `            ``else` `{` `                ``temp.next = s3.peek();` `            ``}` `        ``}` `        ``printList(prev);` `    ``}`   `    ``/* Utility function to print a linked list */` `    ``static` `void` `printList(Node head)` `    ``{` `        ``while` `(head.next != ``null``) {` `            ``System.out.print(head.data + ``" -> "``);` `            ``head = head.next;` `        ``}` `        ``System.out.println(head.data);` `    ``}`   `    ``// 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 : "``);` `        ``list.printList(head1);`   `        ``// creating second list` `        ``list.head2 = ``new` `Node(``8``);` `        ``list.head2.next = ``new` `Node(``4``);` `        ``System.out.print(``"Second List : "``);` `        ``list.printList(head2);`   `        ``System.out.print(``"Sum List : "``);` `        ``// add the two lists and see the result` `        ``list.addTwoLists(head1, head2);` `    ``}`   `    ``// this code is contributed by Abhijeet` `    ``// Kumar(abhijeet19403)` `}`

## C#

 `// C# program to add two numbers represented by Linked` `// Lists using Stack` `using` `System;` `using` `System.Collections.Generic;` `public` `class` `List {`   `    ``public` `class` `Node {`   `        ``public` `int` `data;` `        ``public` `Node next;`   `        ``public` `Node(``int` `d)` `        ``{` `            ``data = d;` `            ``next = ``null``;` `        ``}` `    ``}` `  `  `    ``public` `static` `Node head1, head2;` `    ``// function that calculates and prints the sum of two` `    ``// numbers represented by linked lists` `    ``public` `void` `addTwoLists(Node l1, Node l2)` `    ``{` `        ``Node prev = ``null``;` `        ``// Create 3 stacks` `        ``Stack s1 = ``new` `Stack();` `        ``Stack s2 = ``new` `Stack();` `        ``Stack s3 = ``new` `Stack();` `        ``// Fill first stack with first List Elements` `        ``while` `(l1 != ``null``) {` `            ``s1.Push(l1);` `            ``l1 = l1.next;` `        ``}` `        ``// Fill second stack with second List Elements` `        ``while` `(l2 != ``null``) {` `            ``s2.Push(l2);` `            ``l2 = l2.next;` `        ``}` `        ``int` `carry = 0;` `        ``// Fill the third stack with the sum of first and` `        ``// second stack` `        ``while` `(s1.Count != 0 && s2.Count != 0) {` `            ``int` `sum` `                ``= s1.Peek().data + s2.Peek().data + carry;` `            ``Node temp = ``new` `Node(sum % 10);` `            ``s3.Push(temp);` `            ``if` `(sum > 9) {` `                ``carry = 1;` `            ``}` `            ``else` `{` `                ``carry = 0;` `            ``}` `            ``s1.Pop();` `            ``s2.Pop();` `        ``}` `        ``while` `(s1.Count != 0) {` `            ``int` `sum = carry + s1.Peek().data;` `            ``Node temp = ``new` `Node(sum % 10);` `            ``s3.Push(temp);` `            ``if` `(sum > 9) {` `                ``carry = 1;` `            ``}` `            ``else` `{` `                ``carry = 0;` `            ``}` `            ``s1.Pop();` `        ``}` `        ``while` `(s2.Count != 0) {` `            ``int` `sum = carry + s2.Peek().data;` `            ``Node temp = ``new` `Node(sum % 10);` `            ``s3.Push(temp);` `            ``if` `(sum > 9) {` `                ``carry = 1;` `            ``}` `            ``else` `{` `                ``carry = 0;` `            ``}` `            ``s2.Pop();` `        ``}` `        ``// If carry is still present create a new node with` `        ``// value 1 and push it to the third stack` `        ``if` `(carry == 1) {` `            ``Node temp = ``new` `Node(1);` `            ``s3.Push(temp);` `        ``}` `        ``// Link all the elements inside third stack with` `        ``// each other` `        ``if` `(s3.Count != 0)` `            ``prev = s3.Peek();` `        ``while` `(s3.Count != 0) {` `            ``Node temp = s3.Peek();` `            ``s3.Pop();` `            ``if` `(s3.Count == 0) {` `                ``temp.next = ``null``;` `            ``}` `            ``else` `{` `                ``temp.next = s3.Peek();` `            ``}` `        ``}` `        ``printList(prev);` `    ``}`   `    ``/* Utility function to print a linked list */` `    ``public` `void` `printList(Node head)` `    ``{` `        ``while` `(head.next != ``null``) {` `            ``Console.Write(head.data + ``" -> "``);` `            ``head = head.next;` `        ``}` `        ``Console.WriteLine(head.data);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``List list = ``new` `List();`   `        ``// creating first list` `        ``Node head1 = ``new` `Node(7);` `        ``head1.next = ``new` `Node(5);` `        ``head1.next.next = ``new` `Node(9);` `        ``head1.next.next.next = ``new` `Node(4);` `        ``head1.next.next.next.next = ``new` `Node(6);` `        ``Console.Write(``"First List : "``);` `        ``list.printList(head1);`   `        ``// creating second list` `        ``Node head2 = ``new` `Node(8);` `        ``head2.next = ``new` `Node(4);` `        ``Console.Write(``"Second List : "``);` `        ``list.printList(head2);`   `        ``Console.Write(``"Resultant List : "``);` `        ``// add the two lists and see the result` `        ``list.addTwoLists(head1, head2);` `    ``}` `}`   `// This code is contributed by Abhijeet Kumar(abhijeet19403)`

Output

```First List : 7 -> 5 -> 9 -> 4 -> 6
Second List : 8 -> 4
Sum List : 7 -> 6 -> 0 -> 3 -> 0```

Time Complexity: O(n), Here n is length of the larger list
Auxiliary Space: O(n), Extra space is used in storing the elements in the stack.

## Add two numbers represented by linked lists by Traversing On Larger List:

Follow steps below to solve the problem:

• First, we calculate the sizes of both the linked lists, size1 and size2, respectively.
• Then we traverse the bigger linked list, if any, and decrement till the size of both become the same.
• Now we traverse both linked lists till the end.
• Now the backtracking occurs while performing addition.

Below is the implementation of above approach:

## C++

 `#include ` `using` `namespace` `std;`   `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `};`   `// recursive function` `Node* addition(Node* temp1, Node* temp2, ``int` `size1,` `               ``int` `size2)` `{` `    ``// creating a new Node` `    ``Node* newNode` `        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));`   `    ``// base case` `    ``if` `(temp1->next == NULL && temp2->next == NULL) {` `        ``// addition of current nodes which is the last nodes` `        ``// of both linked lists` `        ``newNode->data = (temp1->data + temp2->data);`   `        ``// set this current node's link null` `        ``newNode->next = NULL;`   `        ``// return the current node` `        ``return` `newNode;` `    ``}`   `    ``// creating a node that contains sum of previously added` `    ``// number` `    ``Node* returnedNode` `        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));`   `    ``// if sizes are same then we move in both linked list` `    ``if` `(size2 == size1) {` `        ``// recursively call the function` `        ``// move ahead in both linked list` `        ``returnedNode = addition(temp1->next, temp2->next,` `                                ``size1 - 1, size2 - 1);`   `        ``// add the current nodes and append the carry` `        ``newNode->data = (temp1->data + temp2->data)` `                        ``+ ((returnedNode->data) / 10);` `    ``}` `    ``// or else we just move in big linked list` `    ``else` `{` `        ``// recursively call the function` `        ``// move ahead in big linked list` `        ``returnedNode = addition(temp1, temp2->next, size1,` `                                ``size2 - 1);`   `        ``// add the current node and carry` `        ``newNode->data` `            ``= (temp2->data) + ((returnedNode->data) / 10);` `    ``}`   `    ``// this node contains previously added numbers` `    ``// so we need to set only rightmost digit of it` `    ``returnedNode->data = (returnedNode->data) % 10;`   `    ``// set the returned node to the current node` `    ``newNode->next = returnedNode;`   `    ``// return the current node` `    ``return` `newNode;` `}`   `// Function to add two numbers represented by nexted list.` `struct` `Node* addTwoLists(``struct` `Node* head1,` `                         ``struct` `Node* head2)` `{` `    ``struct` `Node *temp1, *temp2, *ans = NULL;`   `    ``temp1 = head1;` `    ``temp2 = head2;`   `    ``int` `size1 = 0, size2 = 0;`   `    ``// calculating the size of first linked list` `    ``while` `(temp1 != NULL) {` `        ``temp1 = temp1->next;` `        ``size1++;` `    ``}` `    ``// calculating the size of second linked list` `    ``while` `(temp2 != NULL) {` `        ``temp2 = temp2->next;` `        ``size2++;` `    ``}`   `    ``Node* returnedNode` `        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));`   `    ``// traverse the bigger linked list` `    ``if` `(size2 > size1) {` `        ``returnedNode = addition(head1, head2, size1, size2);` `    ``}` `    ``else` `{` `        ``returnedNode = addition(head2, head1, size2, size1);` `    ``}`   `    ``// creating new node if head node is >10` `    ``if` `(returnedNode->data >= 10) {` `        ``ans = (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));` `        ``ans->data = (returnedNode->data) / 10;` `        ``returnedNode->data = returnedNode->data % 10;` `        ``ans->next = returnedNode;` `    ``}` `    ``else` `        ``ans = returnedNode;`   `    ``// return the head node of linked list that contains` `    ``// answer` `    ``return` `ans;` `}`   `void` `Display(Node* head)` `{` `    ``if` `(head == NULL) {` `        ``return``;` `    ``}` `    ``while` `(head->next != NULL) {` `        ``cout << head->data << ``" -> "``;` `        ``head = head->next;` `    ``}` `    ``cout << head->data << endl;` `}` `// Function that adds element at the end of the Linked List` `void` `push(Node** head_ref, ``int` `d)` `{` `    ``Node* new_node` `        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));` `    ``new_node->data = d;` `    ``new_node->next = NULL;` `    ``if` `(*head_ref == NULL) {` `        ``new_node->next = *head_ref;` `        ``*head_ref = new_node;` `        ``return``;` `    ``}` `    ``Node* last = *head_ref;` `    ``while` `(last->next != NULL && last != NULL) {` `        ``last = last->next;` `    ``}` `    ``last->next = new_node;` `    ``return``;` `}` `// Driver Program for above Functions` `int` `main()` `{` `    ``// Creating two lists` `    ``Node* first = NULL;` `    ``Node* second = NULL;` `    ``Node* sum = NULL;` `    ``push(&first, 7);` `    ``push(&first, 5);` `    ``push(&first, 9);` `    ``push(&first, 4);` `    ``push(&first, 6);` `    ``push(&second, 8);` `    ``push(&second, 4);` `    ``cout << ``"First List : "``;` `    ``Display(first);` `    ``cout << ``"Second List : "``;` `    ``Display(second);` `    ``sum = addTwoLists(first, second);` `    ``cout << ``"Sum List : "``;` `    ``Display(sum);` `    ``return` `0;` `}`   `// This code is contributed by Dharmik Parmar`

## Java

 `import` `java.util.*;`   `class` `GFG {`   `    ``static` `class` `Node {` `        ``int` `data;` `        ``Node next;` `    ``};`   `    ``// recursive function` `    ``static` `Node addition(Node temp1, Node temp2, ``int` `size1,` `                         ``int` `size2)` `    ``{` `        ``// creating a new Node` `        ``Node newNode = ``new` `Node();`   `        ``// base case` `        ``if` `(temp1 != ``null` `&& temp2 != ``null` `            ``&& temp1.next == ``null` `&& temp2.next == ``null``) {` `            ``// addition of current nodes which is the last` `            ``// nodes of both linked lists` `            ``newNode.data = (temp1.data + temp2.data);`   `            ``// set this current node's link null` `            ``newNode.next = ``null``;`   `            ``// return the current node` `            ``return` `newNode;` `        ``}`   `        ``// creating a node that contains sum of previously` `        ``// added number` `        ``Node returnedNode = ``new` `Node();`   `        ``// if sizes are same then we move in both linked` `        ``// list` `        ``if` `((temp1 != ``null` `&& temp2 != ``null``)` `            ``&& size2 == size1) {` `            ``// recursively call the function` `            ``// move ahead in both linked list` `            ``returnedNode = addition(temp1.next, temp2.next,` `                                    ``size1 - ``1``, size2 - ``1``);`   `            ``// add the current nodes and append the carry` `            ``newNode.data = (temp1.data + temp2.data)` `                           ``+ ((returnedNode.data) / ``10``);` `        ``}` `        ``// or else we just move in big linked list` `        ``else` `if` `(temp1 != ``null` `&& temp2 != ``null``) {` `            ``// recursively call the function` `            ``// move ahead in big linked list` `            ``returnedNode = addition(temp1, temp2.next,` `                                    ``size1, size2 - ``1``);`   `            ``// add the current node and carry` `            ``newNode.data` `                ``= (temp2.data) + ((returnedNode.data) / ``10``);` `        ``}`   `        ``// this node contains previously added numbers` `        ``// so we need to set only rightmost digit of it` `        ``returnedNode.data = (returnedNode.data) % ``10``;`   `        ``// set the returned node to the current node` `        ``newNode.next = returnedNode;`   `        ``// return the current node` `        ``return` `newNode;` `    ``}`   `    ``// Function to add two numbers represented by nexted` `    ``// list.` `    ``static` `Node addTwoLists(Node head1, Node head2)` `    ``{` `        ``Node temp1, temp2, ans = ``null``;`   `        ``temp1 = head1;` `        ``temp2 = head2;`   `        ``int` `size1 = ``0``, size2 = ``0``;`   `        ``// calculating the size of first linked list` `        ``while` `(temp1 != ``null``) {` `            ``temp1 = temp1.next;` `            ``size1++;` `        ``}` `        ``// calculating the size of second linked list` `        ``while` `(temp2 != ``null``) {` `            ``temp2 = temp2.next;` `            ``size2++;` `        ``}`   `        ``Node returnedNode = ``new` `Node();`   `        ``// traverse the bigger linked list` `        ``if` `(size2 > size1) {` `            ``returnedNode` `                ``= addition(head1, head2, size1, size2);` `        ``}` `        ``else` `{` `            ``returnedNode` `                ``= addition(head2, head1, size2, size1);` `        ``}`   `        ``// creating new node if head node is >10` `        ``if` `(returnedNode.data >= ``10``) {` `            ``ans = ``new` `Node();` `            ``ans.data = (returnedNode.data) / ``10``;` `            ``returnedNode.data = returnedNode.data % ``10``;` `            ``ans.next = returnedNode;` `        ``}` `        ``else` `            ``ans = returnedNode;`   `        ``// return the head node of linked list that contains` `        ``// answer` `        ``return` `ans;` `    ``}`   `    ``static` `void` `Display(Node head)` `    ``{` `        ``if` `(head == ``null``) {` `            ``return``;` `        ``}` `        ``while` `(head.next != ``null``) {` `            ``System.out.print(head.data + ``" -> "``);` `            ``head = head.next;` `        ``}` `        ``System.out.print(head.data + ``"\n"``);` `    ``}` `    ``// Function that adds element at the end of the Linked` `    ``// List` `    ``static` `Node push(Node head_ref, ``int` `d)` `    ``{` `        ``Node new_node = ``new` `Node();` `        ``new_node.data = d;` `        ``new_node.next = ``null``;` `        ``if` `(head_ref == ``null``) {` `            ``new_node.next = head_ref;` `            ``head_ref = new_node;` `            ``return` `head_ref;` `        ``}` `        ``Node last = head_ref;` `        ``while` `(last.next != ``null` `&& last != ``null``) {` `            ``last = last.next;` `        ``}` `        ``last.next = new_node;` `        ``return` `head_ref;` `    ``}` `    ``// Driver Program for above Functions` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Creating two lists` `        ``Node first = ``null``;` `        ``Node second = ``null``;` `        ``Node sum = ``null``;` `        ``first = push(first, ``7``);` `        ``first = push(first, ``5``);` `        ``first = push(first, ``9``);` `        ``first = push(first, ``4``);` `        ``first = push(first, ``6``);` `        ``second = push(second, ``8``);` `        ``second = push(second, ``4``);` `        ``System.out.print(``"First List : "``);` `        ``Display(first);` `        ``System.out.print(``"Second List : "``);` `        ``Display(second);` `        ``sum = addTwoLists(first, second);` `        ``System.out.print(``"Sum List : "``);` `        ``Display(sum);` `    ``}` `}`   `// This code contributed by shikhasingrajput`

## Python3

 `# Python code for the above approach` `class` `Node:` `    ``def` `__init__(``self``):` `        ``self``.data ``=` `None` `        ``self``.``next` `=` `None`   `# recursive function` `def` `addition(temp1, temp2, size1, size2):`   `    ``# creating a new Node` `    ``newNode ``=` `Node()`   `    ``# base case` `    ``if` `temp1 ``is` `not` `None` `and` `temp2 ``is` `not` `None` `and` `temp1.``next` `is` `None` `and` `temp2.``next` `is` `None``:`   `        ``# addition of current nodes which is the last` `        ``# nodes of both linked lists` `        ``newNode.data ``=` `(temp1.data ``+` `temp2.data)`   `        ``# set this current node's link null` `        ``newNode.``next` `=` `None`   `        ``# return the current node` `        ``return` `newNode`   `    ``# creating a node that contains sum of previously` `    ``# added number` `    ``returnedNode ``=` `Node()`   `    ``# if sizes are same then we move in both linked` `    ``# list` `    ``if` `temp1 ``is` `not` `None` `and` `temp2 ``is` `not` `None` `and` `size2 ``=``=` `size1:`   `        ``# recursively call the function` `        ``# move ahead in both linked list` `        ``returnedNode ``=` `addition(temp1.``next``, temp2.``next``, size1 ``-` `1``, size2 ``-` `1``)`   `        ``# add the current nodes and append the carry` `        ``newNode.data ``=` `(temp1.data ``+` `temp2.data) ``+` `((returnedNode.data) ``/``/` `10``)`   `    ``# or else we just move in big linked list` `    ``elif` `temp1 ``is` `not` `None` `and` `temp2 ``is` `not` `None``:`   `        ``# recursively call the function` `        ``# move ahead in big linked list` `        ``returnedNode ``=` `addition(temp1, temp2.``next``, size1, size2 ``-` `1``)`   `        ``# add the current node and carry` `        ``newNode.data ``=` `(temp2.data) ``+` `((returnedNode.data) ``/``/` `10``)`   `    ``# this node contains previously added numbers` `    ``# so we need to set only rightmost digit of it` `    ``returnedNode.data ``=` `(returnedNode.data) ``%` `10`   `    ``# set the returned node to the current node` `    ``newNode.``next` `=` `returnedNode`   `    ``# return the current node` `    ``return` `newNode`   `# Function to add two numbers represented by nexted` `# list.` `def` `addTwoLists(head1, head2):` `    ``temp1 ``=` `head1` `    ``temp2 ``=` `head2` `    ``size1 ``=` `0` `    ``size2 ``=` `0`   `    ``# calculating the size of first linked list` `    ``while` `temp1 ``is` `not` `None``:` `        ``temp1 ``=` `temp1.``next` `        ``size1 ``+``=` `1`   `    ``# calculating the size of second linked list` `    ``while` `temp2 ``is` `not` `None``:` `        ``temp2 ``=` `temp2.``next` `        ``size2 ``+``=` `1` `    ``returnedNode ``=` `Node()`   `    ``# traverse the bigger linked list` `    ``if` `size2 > size1:` `        ``returnedNode ``=` `addition(head1, head2, size1, size2)` `    ``else``:` `        ``returnedNode ``=` `addition(head2, head1, size2, size1)`   `    ``# creating new node if head node is >10` `    ``if` `returnedNode.data >``=` `10``:` `        ``ans ``=` `Node()` `        ``ans.data ``=` `(returnedNode.data) ``/``/` `10` `        ``returnedNode.data ``=` `returnedNode.data ``%` `10` `        ``ans.``next` `=` `returnedNode` `    ``else``:` `        ``ans ``=` `returnedNode`   `    ``# return the head node of linked list that contains` `    ``# answer` `    ``return` `ans`     `def` `Display(head):` `    ``if` `head ``is` `None``:` `        ``return` `    ``while` `head.``next` `is` `not` `None``:` `        ``print``(``str``(head.data) ``+` `" -> "``, end``=``"")` `        ``head ``=` `head.``next` `    ``print``(``str``(head.data))`   `# Function that adds element at the end of the Linked` `# List` `def` `push(head_ref, d):` `    ``new_node ``=` `Node()` `    ``new_node.data ``=` `d` `    ``new_node.``next` `=` `None` `    ``if` `head_ref ``is` `None``:` `        ``new_node.``next` `=` `head_ref` `        ``head_ref ``=` `new_node` `        ``return` `head_ref` `    ``last ``=` `head_ref` `    ``while` `last.``next` `is` `not` `None` `and` `last ``is` `not` `None``:` `        ``last ``=` `last.``next` `    ``last.``next` `=` `new_node` `    ``return` `head_ref`     `# Creating two lists` `first ``=` `None` `second ``=` `None` `sum` `=` `None` `first ``=` `push(first, ``7``)` `first ``=` `push(first, ``5``)` `first ``=` `push(first, ``9``)` `first ``=` `push(first, ``4``)` `first ``=` `push(first, ``6``)` `second ``=` `push(second, ``8``)` `second ``=` `push(second, ``4``)` `print``(``"First List : "``, end``=``"")` `Display(first)` `print``(``"Second List : "``, end``=``"")` `Display(second)` `sum` `=` `addTwoLists(first, second)` `print``(``"Sum List : "``, end``=``"")` `Display(``sum``)`   `# This code contributed by Prasad Kandekar(prasad264)`

## C#

 `// C# code for the above approach` `using` `System;`   `class` `Node {` `  ``public` `int` `data;` `  ``public` `Node next;` `}`   `public` `class` `GFG {`   `  ``// recursive function` `  ``static` `Node addition(Node temp1, Node temp2, ``int` `size1,` `                       ``int` `size2)` `  ``{` `    ``// creating a new Node` `    ``Node newNode = ``new` `Node();`   `    ``// base case` `    ``if` `(temp1 != ``null` `&& temp2 != ``null` `        ``&& temp1.next == ``null` `&& temp2.next == ``null``) {` `      ``// addition of current nodes which is the last` `      ``// nodes of both linked lists` `      ``newNode.data = (temp1.data + temp2.data);`   `      ``// set this current node's link null` `      ``newNode.next = ``null``;`   `      ``// return the current node` `      ``return` `newNode;` `    ``}`   `    ``// creating a node that contains sum of previously` `    ``// added number` `    ``Node returnedNode = ``new` `Node();`   `    ``// if sizes are same then we move in both linked` `    ``// list` `    ``if` `((temp1 != ``null` `&& temp2 != ``null``)` `        ``&& size2 == size1) {` `      ``// recursively call the function` `      ``// move ahead in both linked list` `      ``returnedNode = addition(temp1.next, temp2.next,` `                              ``size1 - 1, size2 - 1);`   `      ``// add the current nodes and append the carry` `      ``newNode.data = (temp1.data + temp2.data)` `        ``+ ((returnedNode.data) / 10);` `    ``}` `    ``// or else we just move in big linked list` `    ``else` `if` `(temp1 != ``null` `&& temp2 != ``null``) {` `      ``// recursively call the function` `      ``// move ahead in big linked list` `      ``returnedNode = addition(temp1, temp2.next,` `                              ``size1, size2 - 1);`   `      ``// add the current node and carry` `      ``newNode.data` `        ``= (temp2.data) + ((returnedNode.data) / 10);` `    ``}`   `    ``// this node contains previously added numbers` `    ``// so we need to set only rightmost digit of it` `    ``returnedNode.data = (returnedNode.data) % 10;`   `    ``// set the returned node to the current node` `    ``newNode.next = returnedNode;`   `    ``// return the current node` `    ``return` `newNode;` `  ``}`   `  ``// Function to add two numbers represented by nexted` `  ``// list.` `  ``static` `Node addTwoLists(Node head1, Node head2)` `  ``{` `    ``Node temp1, temp2, ans = ``null``;`   `    ``temp1 = head1;` `    ``temp2 = head2;`   `    ``int` `size1 = 0, size2 = 0;`   `    ``// calculating the size of first linked list` `    ``while` `(temp1 != ``null``) {` `      ``temp1 = temp1.next;` `      ``size1++;` `    ``}` `    ``// calculating the size of second linked list` `    ``while` `(temp2 != ``null``) {` `      ``temp2 = temp2.next;` `      ``size2++;` `    ``}`   `    ``Node returnedNode = ``new` `Node();`   `    ``// traverse the bigger linked list` `    ``if` `(size2 > size1) {` `      ``returnedNode` `        ``= addition(head1, head2, size1, size2);` `    ``}` `    ``else` `{` `      ``returnedNode` `        ``= addition(head2, head1, size2, size1);` `    ``}`   `    ``// creating new node if head node is >10` `    ``if` `(returnedNode.data >= 10) {` `      ``ans = ``new` `Node();` `      ``ans.data = (returnedNode.data) / 10;` `      ``returnedNode.data = returnedNode.data % 10;` `      ``ans.next = returnedNode;` `    ``}` `    ``else` `      ``ans = returnedNode;`   `    ``// return the head node of linked list that contains` `    ``// answer` `    ``return` `ans;` `  ``}`   `  ``static` `void` `Display(Node head)` `  ``{` `    ``if` `(head == ``null``) {` `      ``return``;` `    ``}` `    ``while` `(head.next != ``null``) {` `      ``Console.Write(head.data + ``" -> "``);` `      ``head = head.next;` `    ``}` `    ``Console.Write(head.data + ``"\n"``);` `  ``}`   `  ``// Function that adds element at the end of the Linked` `  ``// List` `  ``static` `Node push(Node head_ref, ``int` `d)` `  ``{` `    ``Node new_node = ``new` `Node();` `    ``new_node.data = d;` `    ``new_node.next = ``null``;` `    ``if` `(head_ref == ``null``) {` `      ``new_node.next = head_ref;` `      ``head_ref = new_node;` `      ``return` `head_ref;` `    ``}` `    ``Node last = head_ref;` `    ``while` `(last.next != ``null` `&& last != ``null``) {` `      ``last = last.next;` `    ``}` `    ``last.next = new_node;` `    ``return` `head_ref;` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Creating two lists` `    ``Node first = ``null``;` `    ``Node second = ``null``;` `    ``Node sum = ``null``;` `    ``first = push(first, 7);` `    ``first = push(first, 5);` `    ``first = push(first, 9);` `    ``first = push(first, 4);` `    ``first = push(first, 6);` `    ``second = push(second, 8);` `    ``second = push(second, 4);` `    ``Console.Write(``"First List : "``);` `    ``Display(first);` `    ``Console.Write(``"Second List : "``);` `    ``Display(second);` `    ``sum = addTwoLists(first, second);` `    ``Console.Write(``"Sum List : "``);` `    ``Display(sum);` `  ``}` `}`   `// This code contributed by lokesh`

Output

```First List : 7 -> 5 -> 9 -> 4 -> 6
Second List : 8 -> 4
Sum List : 7 -> 6 -> 0 -> 3 -> 0```

Time Complexity: O(M + N), where M and N are size of list 1 and list 2 respectively
Auxiliary Space: O(1)

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

In this approach we simulate how in reality we add two numbers. In the code we have taken 9->8->7 and 1->2->3 as two numbers to add. What we do is reverse these two lists to get 7->8->9 and 3->2->1 and start from the head of the lists to add numbers of individual nodes like we would in practice if we add two numbers.

For example,  first we add 7 and 3 to get 10, which means carry = 1 and value of new node will be 0. Now we continue this till the end of the list.

Follow steps below to solve the problem:

• Reverse the two number lists.
• Simulate addition on nodes one by one. Append each node before the already calculated sum nodes.( You will better understand this step in code)
• In the end we will get the final answer and we can return the head node.

Below is the implementation of above approach:

## C++

 `// C++ Code to add two nodes by reversing the two lists`   `#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 off 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;` `}`   `struct` `Node* reverseList(``struct` `Node* list)` `{` `    ``Node *prev = NULL, *cur = list, *next = NULL;` `    ``while` `(cur != NULL) {` `        ``next = cur->next;` `        ``cur->next = prev;` `        ``prev = cur;` `        ``cur = next;` `    ``}` `    ``return` `prev;` `}`   `//----------------------------------------------------------------------------`   `Node* addTwoLists(Node* first, Node* second)` `{` `    ``// code here` `    ``first = reverseList(first);` `    ``second = reverseList(second);`   `    ``int` `carry = 0;` `    ``Node *head = NULL, *prev = NULL;` `    ``Node* sum = NULL;` `    ``// if any one of these is left we are still left with addition` `    ``while` `(first != NULL or second != NULL or carry == 1)` `    ``{` `        ``int` `newVal = carry;` `        ``if` `(first)` `            ``newVal += first->data;` `        ``if` `(second)` `            ``newVal += second->data;` `        ``// to be used in the next node calculation` `        ``carry = newVal / 10;` `        ``newVal = newVal % 10;` `        ``Node* newNode = (Node*)``malloc``(``sizeof``(Node));` `        ``newNode->data = newVal;` `        ``// appending in the beginning of the final ans list,` `        ``// this way we do not have to reverse in the end` `        ``newNode->next = sum;` `        ``sum = newNode;` `        ``// initialising nodes for next iteration`   `        ``if` `(first)` `            ``first = first->next;` `        ``if` `(second)` `            ``second = second->next;` `    ``}`   `    ``return` `sum;` `}`   `//----------------------------------------------------------------------------`   `// { Driver Code Starts.`   `int` `main()` `{` `    ``Node* first = NULL;` `    ``Node* second = NULL;`   `    ``push(&first, 6);` `    ``push(&first, 4);` `    ``push(&first, 9);` `    ``push(&first, 5);` `    ``push(&first, 7);`   `    ``push(&second, 4);` `    ``push(&second, 8);`   `    ``Node* ans = addTwoLists(first, second);`   `    ``cout << ``"Sum is : "``;` `    ``printList(ans);`   `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C Code to add two nodes by reversing the two lists`   `#include ` `#include `   `/* Linked list Node */` `typedef` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `} Node;`   `// Function to create a new node with given data` `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 off 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) {` `        ``printf``(``"%d "``, n->data);` `        ``n = n->next;` `    ``}` `    ``printf``(``"\n"``);` `}`   `Node* reverseList(Node* list)` `{` `    ``Node *prev = NULL, *cur = list, *next = NULL;` `    ``while` `(cur != NULL) {` `        ``next = cur->next;` `        ``cur->next = prev;` `        ``prev = cur;` `        ``cur = next;` `    ``}` `    ``return` `prev;` `}`   `//----------------------------------------------------------------------------`   `Node* addTwoLists(Node* first, Node* second)` `{` `    ``// code here` `    ``first = reverseList(first);` `    ``second = reverseList(second);`   `    ``int` `carry = 0;` `    ``Node *head = NULL, *prev = NULL;` `    ``Node* sum = NULL;`   `    ``while` `(first != NULL || second != NULL || carry == 1)` `    ``// if any one of these is left we are stil left with` `    ``// addition` `    ``{` `        ``int` `newVal = carry;` `        ``if` `(first)` `            ``newVal += first->data;` `        ``if` `(second)` `            ``newVal += second->data;` `        ``// to be used in the next node calculation` `        ``carry = newVal / 10;` `        ``newVal = newVal % 10;` `        ``Node* newNode = (Node*)``malloc``(``sizeof``(Node));` `        ``newNode->data = newVal;` `        ``// appending in the beginning of the final ans list,` `        ``// this way we do not have to reverse in the end` `        ``newNode->next = sum;` `        ``sum = newNode;` `        ``// initialising nodes for next iteration` `        ``if` `(first)` `            ``first = first->next;` `        ``if` `(second)` `            ``second = second->next;` `    ``}` `    ``return` `sum;` `}`   `//----------------------------------------------------------------------------`   `// { Driver Code Starts.`   `int` `main()` `{` `    ``Node* first = NULL;` `    ``Node* second = NULL;`   `    ``push(&first, 6);` `    ``push(&first, 4);` `    ``push(&first, 9);` `    ``push(&first, 5);` `    ``push(&first, 7);`   `    ``push(&second, 4);` `    ``push(&second, 8);`   `    ``Node* ans = addTwoLists(first, second);`   `    ``printf``(``"Sum is : "``);` `    ``printList(ans);`   `    ``return` `0;` `}`

## Java

 `// Java program to add two numbers represented by Linked` `// Lists by reversing lists` `import` `java.util.*;`   `class` `LinkedList {`   `    ``static` `Node head1, head2;`   `    ``static` `class` `Node {`   `        ``int` `data;` `        ``Node next;`   `        ``Node(``int` `d)` `        ``{` `            ``data = d;` `            ``next = ``null``;` `        ``}` `    ``}` `    ``// function to reverse the linked list and return the` `    ``// head of the reversed list` `    ``static` `Node reverseList(Node list)` `    ``{` `        ``Node prev = ``null``, curr = list, next = ``null``;` `        ``while` `(curr != ``null``) {` `            ``next = curr.next;` `            ``curr.next = prev;` `            ``prev = curr;` `            ``curr = next;` `        ``}` `        ``return` `prev;` `    ``}` `    ``// function that calculates and prints the sum of two` `    ``// numbers represented` `    ``// by linked lists`   `    ``static` `void` `addTwoLists(Node first, Node second)` `    ``{` `        ``// code here` `        ``first = reverseList(first);` `        ``second = reverseList(second);`   `        ``int` `carry = ``0``;` `        ``Node head = ``null``, prev = ``null``;` `        ``Node sum = ``null``;`   `        ``while` `(first != ``null` `|| second != ``null` `               ``|| carry` `                      ``== ``1``) ``// if any one of these is left` `                            ``// we are stil left with addition` `        ``{` `            ``int` `newVal = carry;`   `            ``if` `(first != ``null``)` `                ``newVal += first.data;` `            ``if` `(second != ``null``)` `                ``newVal += second.data;`   `            ``carry = newVal / ``10``; ``// to be used in the next` `                                 ``// node calculation` `            ``newVal = newVal % ``10``;`   `            ``Node newNode = ``new` `Node(newVal);` `            ``newNode.next` `                ``= sum; ``// appending in the beginning of the` `                       ``// final ans list, this way we do not` `                       ``// have to reverse in the end` `            ``sum = newNode;`   `            ``if` `(first != ``null``) ``// initialising nodes for` `                               ``// next iteration` `                ``first = first.next;` `            ``if` `(second != ``null``)` `                ``second = second.next;` `        ``}`   `        ``printList(sum);` `    ``}`   `    ``/* Utility function to print a linked list */` `    ``static` `void` `printList(Node head)` `    ``{` `        ``while` `(head.next != ``null``) {` `            ``System.out.print(head.data + ``" -> "``);` `            ``head = head.next;` `        ``}` `        ``System.out.println(head.data);` `    ``}`   `    ``// 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``);`   `        ``// creating second list` `        ``list.head2 = ``new` `Node(``8``);` `        ``list.head2.next = ``new` `Node(``4``);`   `        ``System.out.print(``"Sum List : "``);` `        ``// add the two lists and see the result` `        ``list.addTwoLists(head1, head2);` `    ``}`   `    ``// this code is contributed by Abhijeet` `    ``// Kumar(abhijeet19403)` `}`

## Python3

 `# Python code to add two nodes by reversing the two lists`   `# Node class for linked list` `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.``next` `=` `None`   `# LinkedList class` `class` `LinkedList:` `    ``# Function to reverse the linked list and ` `    ``# return the head of the reversed list` `    ``def` `reverse_list(``self``, ``list``):` `        ``prev ``=` `None` `        ``curr ``=` `list` `        ``next` `=` `None` `        ``while` `curr ``is` `not` `None``:` `            ``next` `=` `curr.``next` `            ``curr.``next` `=` `prev` `            ``prev ``=` `curr` `            ``curr ``=` `next` `        ``return` `prev`   `    ``# Function that calculates and prints the sum ` `    ``# of two numbers represented by linked lists` `    ``def` `add_two_lists(``self``, first, second):` `        ``# Reverse both lists` `        ``first ``=` `self``.reverse_list(first)` `        ``second ``=` `self``.reverse_list(second)`   `        ``carry ``=` `0` `        ``head ``=` `None` `        ``prev ``=` `None` `        ``sum_list ``=` `None`   `        ``# Add the two lists and carry over if necessary` `        ``while` `first ``is` `not` `None` `or` `second ``is` `not` `None` `or` `carry ``=``=` `1``:` `            ``new_val ``=` `carry` `            ``if` `first ``is` `not` `None``:` `                ``new_val ``+``=` `first.data` `            ``if` `second ``is` `not` `None``:` `                ``new_val ``+``=` `second.data` `            ``carry ``=` `new_val ``/``/` `10` `            ``new_val ``=` `new_val ``%` `10`   `            ``# Create a new node for the sum and append it ` `            ``# to the beginning of the final ans list` `            ``new_node ``=` `Node(new_val)` `            ``new_node.``next` `=` `sum_list` `            ``sum_list ``=` `new_node`   `            ``# Initialize nodes for the next iteration` `            ``if` `first ``is` `not` `None``:` `                ``first ``=` `first.``next` `            ``if` `second ``is` `not` `None``:` `                ``second ``=` `second.``next`   `        ``self``.print_list(sum_list)`   `    ``# Utility function to print a linked list` `    ``def` `print_list(``self``, head):` `        ``while` `head.``next` `is` `not` `None``:` `            ``print``(head.data, end``=``" "``)` `            ``head ``=` `head.``next` `        ``print``(head.data)`     `# Test the LinkedList class` `linked_list ``=` `LinkedList()`   `# Create first list` `linked_list.head1 ``=` `Node(``7``)` `linked_list.head1.``next` `=` `Node(``5``)` `linked_list.head1.``next``.``next` `=` `Node(``9``)` `linked_list.head1.``next``.``next``.``next` `=` `Node(``4``)` `linked_list.head1.``next``.``next``.``next``.``next` `=` `Node(``6``)`   `# Create second list` `linked_list.head2 ``=` `Node(``8``)` `linked_list.head2.``next` `=` `Node(``4``)`   `print``(``"Sum is:"``, end ``=` `" "``)` `# Add the two lists and see the result` `linked_list.add_two_lists(linked_list.head1, linked_list.head2)`   `# This code is contributed by lokeshmvs21.`

## C#

 `// C# program to add two numbers represented by Linked` `// Lists by reversing lists` `using` `System;` `using` `System.Collections.Generic;` `public` `class` `List {`   `    ``public` `class` `Node {`   `        ``public` `int` `data;` `        ``public` `Node next;`   `        ``public` `Node(``int` `d)` `        ``{` `            ``data = d;` `            ``next = ``null``;` `        ``}` `    ``}` `    ``public` `static` `Node head1, head2;`   `    ``// function to reverse the linked list and return the` `    ``// head of the reversed list` `    ``static` `Node reverseList(Node list)` `    ``{` `        ``Node prev = ``null``, curr = list, next = ``null``;` `        ``while` `(curr != ``null``) {` `            ``next = curr.next;` `            ``curr.next = prev;` `            ``prev = curr;` `            ``curr = next;` `        ``}` `        ``return` `prev;` `    ``}` `    ``// function that calculates and prints the sum of two` `    ``// numbers represented` `    ``// by linked lists`   `    ``static` `void` `addTwoLists(Node first, Node second)` `    ``{` `        ``// code here` `        ``first = reverseList(first);` `        ``second = reverseList(second);`   `        ``int` `carry = 0;`   `        ``Node sum = ``null``;` `        ``// if any one of these is left we are stil left with` `        ``// addition` `        ``while` `(first != ``null` `|| second != ``null` `               ``|| carry == 1) {` `            ``int` `newVal = carry;`   `            ``if` `(first != ``null``)` `                ``newVal += first.data;` `            ``if` `(second != ``null``)` `                ``newVal += second.data;`   `            ``carry = newVal / 10; ``// to be used in the next` `                                 ``// node calculation` `            ``newVal = newVal % 10;`   `            ``Node newNode = ``new` `Node(newVal);` `            ``newNode.next = sum;` `            ``// appending in the beginning of the final ans` `            ``// list,` `            ``// this way we do not have to reverse in the end` `            ``sum = newNode;`   `            ``if` `(first != ``null``) ``// initialising nodes for` `                               ``// next iteration` `                ``first = first.next;` `            ``if` `(second != ``null``)` `                ``second = second.next;` `        ``}`   `        ``printList(sum);` `    ``}` `    ``/* Utility function to print a linked list */` `    ``static` `void` `printList(Node head)` `    ``{` `        ``while` `(head.next != ``null``) {` `            ``Console.Write(head.data + ``" -> "``);` `            ``head = head.next;` `        ``}` `        ``Console.WriteLine(head.data);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{`   `        ``// creating first list` `        ``Node head1 = ``new` `Node(7);` `        ``head1.next = ``new` `Node(5);` `        ``head1.next.next = ``new` `Node(9);` `        ``head1.next.next.next = ``new` `Node(4);` `        ``head1.next.next.next.next = ``new` `Node(6);`   `        ``// creating second list` `        ``Node head2 = ``new` `Node(8);` `        ``head2.next = ``new` `Node(4);`   `        ``Console.Write(``"Resultant List : "``);` `        ``// add the two lists and see the result` `        ``addTwoLists(head1, head2);` `    ``}` `}`   `// This code is contributed by Abhijeet Kumar(abhijeet19403)`

## Javascript

 `// JavaScript code to add two nodes by reversing the two lists` `  `  `// Node class for linked list` `class Node {` `    ``constructor(data) {` `        ``this``.data = data;` `    ``this``.next = ``null``;` `    ``}` `}`   `// LinkedList class` `class LinkedList {` `    ``// Function to reverse the linked list and` `    ``// return the head of the reversed list` `    ``reverseList(list) {` `        ``let prev = ``null``;` `        ``let curr = list;` `        ``let next = ``null``;` `        ``while` `(curr !== ``null``) {` `            ``next = curr.next;` `            ``curr.next = prev;` `            ``prev = curr;` `            ``curr = next;` `        ``}` `        ``return` `prev;` `    ``}`   `    ``// Function that calculates and prints the sum` `    ``// of two numbers represented by linked lists` `    ``addTwoLists(first, second) {` `        `  `        ``// Reverse both lists` `        ``first = ``this``.reverseList(first);` `        ``second = ``this``.reverseList(second);` `    `  `        ``let carry = 0;` `        ``let head = ``null``;` `        ``let prev = ``null``;` `        ``let sumList = ``null``;` `    `  `        ``// Add the two lists and carry over if necessary` `        ``while` `(first !== ``null` `|| second !== ``null` `|| carry === 1) {` `            ``let newVal = carry;` `            ``if` `(first !== ``null``) {` `                ``newVal += first.data;` `            ``}` `            ``if` `(second !== ``null``) {` `                ``newVal += second.data;` `            ``}` `            ``carry = Math.floor(newVal / 10);` `            ``newVal = newVal % 10;` `    `  `            ``// Create a new node for the sum and append it` `            ``// to the beginning of the final ans list` `            ``let newNode = ``new` `Node(newVal);` `            ``newNode.next = sumList;` `            ``sumList = newNode;` `    `  `            ``// Initialize nodes for the next iteration` `            ``if` `(first !== ``null``) {` `                ``first = first.next;` `            ``}` `            ``if` `(second !== ``null``) {` `                ``second = second.next;` `            ``}` `        ``}` `    `  `        ``this``.printList(sumList);` `    ``}` `    `  `    ``// Utility function to print a linked list` `    ``printList(head) {` `        ``while` `(head.next !== ``null``) {` `            ``console.log(head.data + ``" "``);` `            ``head = head.next;` `        ``}` `        ``console.log(head.data);` `    ``}` `}`   `// Test the LinkedList class` `const linkedList = ``new` `LinkedList();`   `// Create first list` `linkedList.head1 = ``new` `Node(7);` `linkedList.head1.next = ``new` `Node(5);` `linkedList.head1.next.next = ``new` `Node(9);` `linkedList.head1.next.next.next = ``new` `Node(4);` `linkedList.head1.next.next.next.next = ``new` `Node(6);`   `// Create second list` `linkedList.head2 = ``new` `Node(8);` `linkedList.head2.next = ``new` `Node(4);`   `console.log(``"Sum is:"``);`   `// Add the two lists and see the result` `linkedList.addTwoLists(linkedList.head1, linkedList.head2);`   `// This code is contributed by Prasad Kandekar(prasad264)`

Output

`Sum is : 7 6 0 3 0 `

Time Complexity: O(max(M, N)), where M and N are numbers of nodes in first and second lists respectively. The lists need to be traversed only once.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles