Add two numbers represented by linked lists | Set 1 - GeeksforGeeks

12 Apr, 2022
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 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. 
The steps are: 
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.
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
Java
C#
// C++ program to add two numbers// represented by linked list#include <bits/stdc++.h>using namespace std; /* Linked list node */class Node {public:    int data;    Node* next;}; /* Function to create anew 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 thebeginning of the Singly Linked List */void push(Node** head_ref, int new_data){    /* allocate node */    Node* new_node = newNode(new_data);    /* link the old list off the new node */    new_node->next = (*head_ref);    /* move the head to point to the new node */    (*head_ref) = new_node;} /* Adds contents of two linked lists andreturn 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 listvoid 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 program to add two numbers// represented by linked list#include <stdio.h>#include <stdlib.h> /* Linked list node */typedef struct Node {    int data;    struct Node* next;}Node; /* Function to create anew 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 thebeginning of the Singly Linked List */void push(Node** head_ref, int new_data){    /* allocate node */    Node* new_node = newNode(new_data);    /* link the old list off the new node */    new_node->next = (*head_ref);    /* move the head to point to the new node */    (*head_ref) = new_node;} /* Adds contents of two linked lists andreturn 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 listvoid 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 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*}
// C# program to add two numbers// represented by linked listusing 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
First List is 7 5 9 4 6 
Second List is 8 4 
Resultant list is 7 6 0 3 0 
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
Method 2(Using STL): Using the stack data structure
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 >9set carry 1
set carry 1
elseset carry 0
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 
Code:
C++
// C++ program to add two numbers represented by Linked// Lists using Stack#include <bits/stdc++.h>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 listsNode* addTwoNumbers(Node* l1, Node* l2){    Node* prev = NULL;    // Create 3 stacks    stack<Node*> 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 Listvoid 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 Listvoid 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 Functionsint 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;}
First List : 7 -> 5 -> 9 -> 4 -> 6
Second List : 8 -> 4
Sum List : 7 -> 6 -> 0 -> 3 -> 0
Another Approach with time complexity O(N):
The given approach works as following steps: 
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.Finally, the head node is returned to the linked list containing the answer.
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.
Finally, the head node is returned to the linked list containing the answer.
C++
#include <iostream>using namespace std; struct Node {    int data;    struct Node* next;}; // recursive functionNode* 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 Listvoid 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 Functionsint 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
First List : 7 -> 5 -> 9 -> 4 -> 6
Second List : 8 -> 4
Sum List : 7 -> 6 -> 0 -> 3 -> 0
Related Article: Add two numbers represented by linked lists | Set 2
Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem. 
 
amogha_ha
Rajput-Ji
rathbhupendra
andrew1234
praddyumn
aashish1995
prathamjha5683
freshcode7
manishchandwani1212
gulshankumarar231
dharmikparmar7
simmytarika5
anikakapoor
saurabh321gupta
niharikatanwar61
amartyaghoshgfg
RishabhPrabhu
umadevi9616
adityakumar129
Accolite
Amazon
Flipkart
MakeMyTrip
Microsoft
Qualcomm
Snapdeal
Linked List
Flipkart
Accolite
Amazon
Microsoft
Snapdeal
MakeMyTrip
Qualcomm
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Delete a Linked List node at a given position
Queue - Linked List Implementation
Implement a stack using singly linked list
Implementing a Linked List in Java using Class
Circular Linked List | Set 1 (Introduction and Applications)
Remove duplicates from a sorted linked list
Find Length of a Linked List (Iterative and Recursive)
Function to check if a singly linked list is palindrome
Search an element in a Linked List (Iterative and Recursive)
Write a function to delete a Linked List