GeeksforGeeks App
Open App
Browser
Continue

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

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 75946
List2: 8->4 // represents number 84
Output:
Resultant list: 7->6->0->3->0// represents number 76030
Explanation: 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 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 */``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.
• Auxiliary Space: O(1).

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

My Personal Notes arrow_drop_up