Add two numbers represented by linked lists

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

Example:

Input: List1: 5->6->3  // represents number 365
       List2: 8->4->2 //  represents number 248
Output: Resultant list: 3->1->6  // represents number 613


Input: List1: 7->5->9->4->6  // represents number 64957
       List2: 8->4 //  represents number 48
Output: Resultant list: 5->0->0->5->6  // represents number 65005

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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

Below is the implementation of this approach.

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 a new node with given data */
Node *newNode(int data)  
{  
    Node *new_node = new Node(); 
    new_node->data = data;  
    new_node->next = NULL;  
    return new_node;  
}  
  
/* Function to insert a node at the 
beginning of the Singly Linked List */
void push(Node** head_ref, int new_data)  
{  
    /* allocate node */
    Node* new_node = newNode(new_data);  
  
    /* link the old list off the new node */
    new_node->next = (*head_ref);  
  
    /* move the head to point to the new node */
    (*head_ref) = new_node;  
}  
  
/* Adds contents of two linked lists and  
return the head node of resultant list */
Node* addTwoLists (Node* first, Node* second)  
{  
    Node* res = NULL; // res is head node of the resultant list  
    Node *temp, *prev = NULL;  
    int carry = 0, sum;  
  
    while (first != NULL || second != NULL) //while both lists exist  
    {  
        // Calculate value of next digit in resultant list.  
        // The next digit is sum of following things  
        // (i) Carry  
        // (ii) Next digit of first list (if there is a next digit)  
        // (ii) Next digit of second list (if there is a next digit)  
        sum = carry + (first? first->data: 0) + 
                      (second? second->data: 0);  
  
        // update carry for next calulation  
        carry = (sum >= 10)? 1 : 0;  
  
        // update sum if it is greater than 10  
        sum = sum % 10;  
  
        // Create a new node with sum as data  
        temp = newNode(sum);  
  
        // if this is the first node then 
        // set it as head of the resultant list  
        if(res == NULL)  
            res = temp;  
              
        // If this is not the first  
        // node then connect it to the rest. 
        else  
            prev->next = temp;  
  
        // Set prev for next insertion  
        prev = temp;  
  
        // Move first and second pointers to next nodes  
        if (first) first = first->next;  
        if (second) second = second->next;  
    }  
  
    if (carry > 0)  
    temp->next = newNode(carry);  
  
    // return head of the resultant list  
    return res;  
}  
  
// A utility function to print a linked list  
void printList(Node *node)  
{  
    while(node != NULL)  
    {  
        cout << node->data << " ";  
        node = node->next;  
    }  
    cout<<endl;  
}  
  
/* Driver code */
int main(void)  
{  
    Node* res = NULL;  
    Node* first = NULL;  
    Node* second = NULL;  
  
    // create first list 7->5->9->4->6  
    push(&first, 6);  
    push(&first, 4);  
    push(&first, 9);  
    push(&first, 5);  
    push(&first, 7);  
    printf("First List is ");  
    printList(first);  
  
    // create second list 8->4  
    push(&second, 4);  
    push(&second, 8);  
    cout<<"Second List is ";  
    printList(second);  
  
    // Add the two lists and see result  
    res = addTwoLists(first, second);  
    cout<<"Resultant list is ";  
    printList(res);  
  
return 0;  
}  
  
// This code is contributed by rathbhupendra 

C

#include<stdio.h> 
#include<stdlib.h> 
  
/* 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) 
{ 
    struct Node* res = NULL; // res is head node of the resultant list 
    struct Node *temp, *prev = NULL; 
    int carry = 0, sum; 
  
    while (first != NULL || second != NULL) //while both lists exist 
    { 
        // Calculate value of next digit in resultant list. 
        // The next digit is sum of following things 
        // (i)  Carry 
        // (ii) Next digit of first list (if there is a next digit) 
        // (ii) Next digit of second list (if there is a next digit) 
        sum = carry + (first? first->data: 0) + (second? second->data: 0); 
  
        // update carry for next calulation 
        carry = (sum >= 10)? 1 : 0; 
  
        // update sum if it is greater than 10 
        sum = sum % 10; 
  
        // Create a new node with sum as data 
        temp = newNode(sum); 
  
        // if this is the first node then set it as head of the resultant list 
        if(res == NULL) 
            res = temp; 
        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 (first) first = first->next; 
        if (second) second = second->next; 
    } 
  
    if (carry > 0) 
      temp->next = newNode(carry); 
  
    // return head of the resultant list 
    return res; 
} 
  
// A utility function to print a linked list 
void printList(struct Node *node) 
{ 
    while(node != NULL) 
    { 
        printf("%d ", node->data); 
        node = node->next; 
    } 
    printf("\n"); 
} 
  
/* Driver program to test above function */
int main(void) 
{ 
    struct Node* res = NULL; 
    struct Node* first = NULL; 
    struct Node* second = NULL; 
  
    // create first list 7->5->9->4->6 
    push(&first, 6); 
    push(&first, 4); 
    push(&first, 9); 
    push(&first, 5); 
    push(&first, 7); 
    printf("First List is "); 
    printList(first); 
  
    // create second list 8->4 
    push(&second, 4); 
    push(&second, 8); 
    printf("Second List is "); 
    printList(second); 
  
    // Add the two lists and see result 
    res = addTwoLists(first, second); 
    printf("Resultant list is "); 
    printList(res); 
  
   return 0; 
} 

Java

// Java program to add two numbers represented by linked list 
  
class LinkedList { 
  
    static Node head1, head2; 
  
    static class Node { 
  
        int data; 
        Node next; 
  
        Node(int d) { 
            data = d; 
            next = null; 
        } 
    } 
  
    /* Adds contents of two linked lists and return the head node of resultant list */
    Node addTwoLists(Node first, Node second) { 
        Node res = null; // res is head node of the resultant list 
        Node prev = null; 
        Node temp = null; 
        int carry = 0, sum; 
  
        while (first != null || second != null) //while both lists exist 
        { 
            // Calculate value of next digit in resultant list. 
            // The next digit is sum of following things 
            // (i)  Carry 
            // (ii) Next digit of first list (if there is a next digit) 
            // (ii) Next digit of second list (if there is a next digit) 
            sum = carry + (first != null ? first.data : 0) 
                    + (second != null ? second.data : 0); 
  
            // update carry for next calulation 
            carry = (sum >= 10) ? 1 : 0; 
  
            // update sum if it is greater than 10 
            sum = sum % 10; 
  
            // Create a new node with sum as data 
            temp = new Node(sum); 
  
            // if this is the first node then set it as head of 
            // the resultant list 
            if (res == null) { 
                res = temp; 
            } 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 (first != null) { 
                first = first.next; 
            } 
            if (second != null) { 
                second = second.next; 
            } 
        } 
  
        if (carry > 0) { 
            temp.next = new Node(carry); 
        } 
  
        // return head of the resultant list 
        return res; 
    } 
    /* Utility function to print a linked list */
  
    void printList(Node head) { 
        while (head != null) { 
            System.out.print(head.data + " "); 
            head = head.next; 
        } 
        System.out.println(""); 
    } 
  
    public static void main(String[] args) { 
        LinkedList list = new LinkedList(); 
  
        // creating first list 
        list.head1 = new Node(7); 
        list.head1.next = new Node(5); 
        list.head1.next.next = new Node(9); 
        list.head1.next.next.next = new Node(4); 
        list.head1.next.next.next.next = new Node(6); 
        System.out.print("First List is "); 
        list.printList(head1); 
  
        // creating seconnd list 
        list.head2 = new Node(8); 
        list.head2.next = new Node(4); 
        System.out.print("Second List is "); 
        list.printList(head2); 
  
        // add the two lists and see the result 
        Node rs = list.addTwoLists(head1, head2); 
        System.out.print("Resultant List is "); 
        list.printList(rs); 
    } 
} 
  
// this code has been contributed by Mayank Jaiswal 

Python

# Python program to add two numbers represented by linked list 
  
# Node class 
class Node: 
  
    # Constructor to initialize the node object 
    def __init__(self, data): 
        self.data = data 
        self.next = None
  
class LinkedList: 
  
    # Function to initialize head 
    def __init__(self): 
        self.head = None
  
    # Function to insert a new node at the beginning 
    def push(self, new_data): 
        new_node = Node(new_data) 
        new_node.next = self.head 
        self.head = new_node 
  
    # Add contents of two linked lists and return the head 
    # node of resultant list 
    def addTwoLists(self, first, second): 
        prev = None
        temp = None
        carry = 0 
  
        # While both list exists 
        while(first is not None or second is not None): 
  
            # Calculate the value of next digit in 
            # resultant list 
            # The next digit is sum of following things 
            # (i) Carry 
            # (ii) Next digit of first list (if ther is a 
            # next digit) 
            # (iii) Next digit of second list ( if there 
            # is a next digit) 
            fdata = 0 if first is None else first.data 
            sdata = 0 if second is None else second.data 
            Sum = carry + fdata + sdata 
  
            # update carry for next calculation 
            carry = 1 if Sum >= 10 else 0
  
            # update sum if it is greater than 10 
            Sum = Sum if Sum < 10 else Sum % 10
  
            # Create a new node with sum as data 
            temp = Node(Sum) 
  
            # if this is the first node then set it as head 
            # of resultant list 
            if self.head is None: 
                self.head = temp 
            else : 
                prev.next = temp  
  
            # Set prev for next insertion 
            prev = temp 
  
            # Move first and second pointers to next nodes 
            if first is not None: 
                first = first.next
            if second is not None: 
                second = second.next
  
        if carry > 0: 
            temp.next = Node(carry) 
  
    # Utility function to print the linked LinkedList 
    def printList(self): 
        temp = self.head 
        while(temp): 
            print temp.data, 
            temp = temp.next
  
# Driver program to test above function 
first = LinkedList() 
second = LinkedList() 
  
# Create first list 
first.push(6) 
first.push(4) 
first.push(9) 
first.push(5) 
first.push(7) 
print "First List is ", 
first.printList() 
  
# Create second list 
second.push(4) 
second.push(8) 
print "\nSecond List is ", 
second.printList() 
  
# Add the two lists and see result 
res = LinkedList() 
res.addTwoLists(first.head, second.head) 
print "\nResultant list is ", 
res.printList() 
  
# This code is contributed by Nikhil Kumar Singh(nickzuck_007) 

C#

// C# program to add two numbers  
// represented by linked list 
using System; 
  
public class LinkedList 
{ 
  
    Node head1, head2; 
  
    public class Node  
    { 
        public int data; 
        public Node next; 
  
        public Node(int d)  
        { 
            data = d; 
            next = null; 
        } 
    } 
  
    /* Adds contents of two linked lists  
    and return the head node of resultant list */
    Node addTwoLists(Node first, Node second) 
    { 
        // res is head node of the resultant list 
        Node res = null;  
        Node prev = null; 
        Node temp = null; 
        int carry = 0, sum; 
  
        // while both lists exist 
        while (first != null || second != null)  
        { 
            // Calculate value of next digit in resultant list. 
            // The next digit is sum of following things 
            // (i) Carry 
            // (ii) Next digit of first list (if there is a next digit) 
            // (ii) Next digit of second list (if there is a next digit) 
            sum = carry + (first != null ? first.data : 0) 
                    + (second != null ? second.data : 0); 
  
            // update carry for next calulation 
            carry = (sum >= 10) ? 1 : 0; 
  
            // update sum if it is greater than 10 
            sum = sum % 10; 
  
            // Create a new node with sum as data 
            temp = new Node(sum); 
  
            // if this is the first node then set it as head of 
            // the resultant list 
            if (res == null)  
            { 
                res = temp; 
            }  
              
            // If this is not the first 
            // node then connect it to the rest. 
            else 
            { 
                prev.next = temp; 
            } 
  
            // Set prev for next insertion 
            prev = temp; 
  
            // Move first and second pointers to next nodes 
            if (first != null) 
            { 
                first = first.next; 
            } 
            if (second != null)  
            { 
                second = second.next; 
            } 
        } 
  
        if (carry > 0) 
        { 
            temp.next = new Node(carry); 
        } 
  
        // return head of the resultant list 
        return res; 
    } 
    /* Utility function to print a linked list */
  
    void printList(Node head)  
    { 
        while (head != null)  
        { 
            Console.Write(head.data + " "); 
            head = head.next; 
        } 
    Console.WriteLine(""); 
    } 
  
    // Driver code 
    public static void Main(String[] args)  
    { 
        LinkedList list = new LinkedList(); 
  
        // creating first list 
        list.head1 = new Node(7); 
        list.head1.next = new Node(5); 
        list.head1.next.next = new Node(9); 
        list.head1.next.next.next = new Node(4); 
        list.head1.next.next.next.next = new Node(6); 
        Console.Write("First List is "); 
        list.printList(list.head1); 
  
        // creating seconnd list 
        list.head2 = new Node(8); 
        list.head2.next = new Node(4); 
        Console.Write("Second List is "); 
        list.printList(list.head2); 
  
        // add the two lists and see the result 
        Node rs = list.addTwoLists(list.head1, list.head2); 
        Console.Write("Resultant List is "); 
        list.printList(rs); 
    } 
} 
  
// This code contributed by Rajput-Ji 

Output:

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

Time Complexity: O(m + n) where m and n are number of nodes in first and second lists respectively.

Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem.

My Personal Notes

Add two numbers represented by linked lists | Set 1

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

C++

C

Java

Python

C#

Recommended Posts: