Skip to content
Related Articles

Related Articles

Add two numbers represented by Linked List

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 28 Nov, 2022
Improve Article
Save Article

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. 

 

Complete Interview Preparation - GFG

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 <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)
{
    // 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 <stdio.h>
#include <stdlib.h>
  
/* 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;
}
  
/* 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 

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

Add two numbers represented by Linked Lists using Stack:

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 <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 lists
Node* 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 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<Node> s1 = new Stack<Node>();
        Stack<Node> s2 = new Stack<Node>();
        Stack<Node> s3 = new Stack<Node>();
        // 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<Node> s1 = new Stack<Node>();
        Stack<Node> s2 = new Stack<Node>();
        Stack<Node> s3 = new Stack<Node>();
        // 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.
  • Finally, the head node is returned to the linked list containing the answer.

Below is the implementation of above approach:

C++




#include <iostream>
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

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
 

Add two numbers represented by linked lists without Appending Zeros:

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 <bits/stdc++.h>
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 stil 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 <stdio.h>
#include <stdlib.h>
  
/* 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)
}

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)

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.
Space Complexity: O(1)


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!