# C Program To Add Two Numbers Represented By Linked Lists- Set 1

• Last Updated : 20 Dec, 2021

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

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 75946List2: 8->4 // represents number 84Output: Resultant list: 7->6->0->3->0// represents number 76030Explanation: 75946+84=76030
```

Approach: Traverse both lists and One by one pick nodes of both lists and add the values. If the sum is more than 10 then make carry as 1 and reduce sum. If one list has more elements than the other then consider the remaining values of this list as 0. The steps are:

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

Below is the implementation of this approach.

## C

 `// C program to implement the``// above approach``#include ``#include `` ` `// Linked list node ``struct` `Node ``{``    ``int` `data;``    ``struct` `Node* next;``};`` ` `/* Function to create a new node ``   ``with given data */``struct` `Node* newNode(``int` `data)``{``    ``struct` `Node* new_node = ``           ``(``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));``    ``new_node->data = data;``    ``new_node->next = NULL;``    ``return` `new_node;``}`` ` `/* Function to insert a node at the ``   ``beginning of the Singly Linked List */``void` `push(``struct` `Node** head_ref, ``          ``int` `new_data)``{``    ``// Allocate node ``    ``struct` `Node* new_node = newNode(new_data);`` ` `    ``// Link the old list off the new node ``    ``new_node->next = (*head_ref);`` ` `    ``// Move the head to point to the ``    ``// new node ``    ``(*head_ref) = new_node;``}`` ` `/* Adds contents of two linked``   ``lists and return the head node``   ``of resultant list */``struct` `Node* addTwoLists(``struct` `Node* first,``                         ``struct` `Node* second)``{``    ``// res is head node of the resultant ``    ``// list``    ``struct` `Node* res = NULL;``    ``struct` `Node *temp, *prev = NULL;``    ``int` `carry = 0, sum;`` ` `    ``// while both lists exist``    ``while` `(first != NULL || ``           ``second != NULL) ``    ``{``        ``// Calculate value of next digit in ``        ``// resultant list. The next digit is ``        ``// sum of following things``        ``// (i)  Carry``        ``// (ii) Next digit of first``        ``// list (if there is a next digit)``        ``// (ii) Next digit of second``        ``// list (if there is a next digit)``        ``sum = carry + (first ? first->data : 0) + ``              ``(second ? second->data : 0);`` ` `        ``// Update carry for next 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;``}`` ` `// A utility function to print a ``// linked list``void` `printList(``struct` `Node* node)``{``    ``while` `(node != NULL) ``    ``{``        ``printf``(``"%d "``, node->data);``        ``node = node->next;``    ``}``    ``printf``(``""``);``}`` ` `// Driver code``int` `main(``void``)``{``    ``struct` `Node* res = NULL;``    ``struct` `Node* first = NULL;``    ``struct` `Node* second = NULL;`` ` `    ``// Create first list 7->5->9->4->6``    ``push(&first, 6);``    ``push(&first, 4);``    ``push(&first, 9);``    ``push(&first, 5);``    ``push(&first, 7);``    ``printf``(``"First List is "``);``    ``printList(first);`` ` `    ``// Create second list 8->4``    ``push(&second, 4);``    ``push(&second, 8);``    ``printf``(``"Second List is "``);``    ``printList(second);`` ` `    ``// Add the two lists and see result``    ``res = addTwoLists(first, second);``    ``printf``(``"Resultant list is "``);``    ``printList(res);`` ` `    ``return` `0;``}`

Output:

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

Complexity Analysis:

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

Please refer complete article on Add two numbers represented by linked lists | Set 1 for more details!

My Personal Notes arrow_drop_up