Skip to content
Related Articles
Open in App
Not now

Related Articles

Add two numbers represented by Linked List

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 01 Feb, 2023
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 of the new node */
    new_node->next = (*head_ref);
    /* move the head to point to the new node */
    (*head_ref) = new_node;
}
 
/* Adds contents of two linked lists and
return the head node of resultant list */
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 of the new node */
    new_node->next = (*head_ref);
    /* move the head to point to the new node */
    (*head_ref) = new_node;
}
 
/* Adds contents of two linked lists and
return the head node of resultant list */
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 number represented by Linked Lists :

the easy way to add two number in linked list it can be this approach. 

the approach: we have two linked list we just get it into number form if 1->2->3 then number is 123 using while loop and simple math here is how we get toward second last node of linked list and just add to number and multiply by 10. then at last node outside the while loop we add last node value and we get the number in linked list form yo number/integer.also do similar task for second linked list and then add both number and form a third number. and then we use again simple mathnand while loop to get number in last digit(by %10 and /10) and then push a node form every digit in new Linked list at the end here we have our new/resultant linked list.

C++




#include <bits/stdc++.h>
#include<iostream>
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 of the new node */
    new_node->next = (*head_ref);
    /* move the head to point to the new node */
    (*head_ref) = new_node;
}
// function to linked list
void printList(Node* n){
    while (n) {
        cout << n->data << " ";
        n = n->next;
    }
    cout << endl;
}
// function that work on addition operation.
Node* addTwoLists(Node*first , Node*second){
  int num1=0,num2=0;
  //here we get num1 form first linked list.
   while(first->next!=NULL){
     num1 +=first->data;
     num1*=10;
     first=first->next;
   }
   num1+=first->data;
  // here we get num2 form second linked list.
   while(second->next!=NULL){
     num2 +=second->data;
     num2*=10;
     second=second->next;
   }
   num2+=second->data;
  // here we add both number.
   int num3=num1+num2;
   Node* temp=NULL;
   //Node* result=temp;
  // convert num3 into linked list.
   while(num3!=0){
     int last=num3%10;
     push(&temp,last);
     num3=num3/10;
   }
  // finally return resultant linked list.
   return temp;
}
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;
}

Python3




class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
         
class LinkedList:
    def __init__(self):
        self.head = None
    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node
         
    def printList(self):
        n = self.head
        while n:
            print(n.data, end=' ')
            n = n.next
        print()
 
def addTwoLists(first, second):
    num1, num2 = 0, 0
    while first.head:
        num1 = num1*10 + first.head.data
        first.head = first.head.next
    while second.head:
        num2 = num2*10 + second.head.data
        second.head = second.head.next
    num3 = num1 + num2
    temp = LinkedList()
    while num3:
        last = num3 % 10
        temp.push(last)
        num3 = num3 // 10
    return temp
 
if __name__ == '__main__':
    first = LinkedList()
    second = LinkedList()
    first.push(6)
    first.push(4)
    first.push(9)
    first.push(5)
    first.push(7)
 
    second.push(4)
    second.push(8)
 
    ans = addTwoLists(first, second)
 
    print("Sum is : ", end=' ')
    ans.printList()

Output

Sum 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.
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

C#




// C# code for the above approach
using System;
 
class Node {
  public int data;
  public Node next;
}
 
public class GFG {
 
  // 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) {
      Console.Write(head.data + " -> ");
      head = head.next;
    }
    Console.Write(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;
  }
 
  static public void Main()
  {
 
    // 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);
    Console.Write("First List : ");
    Display(first);
    Console.Write("Second List : ");
    Display(second);
    sum = addTwoLists(first, second);
    Console.Write("Sum List : ");
    Display(sum);
  }
}
 
// This code contributed by lokesh

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 still 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)

Python3




# Python code to add two nodes by reversing the two lists
 
# Node class for linked list
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
# LinkedList class
class LinkedList:
    # Function to reverse the linked list and
    # return the head of the reversed list
    def reverse_list(self, list):
        prev = None
        curr = list
        next = None
        while curr is not None:
            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
    def add_two_lists(self, first, second):
        # Reverse both lists
        first = self.reverse_list(first)
        second = self.reverse_list(second)
 
        carry = 0
        head = None
        prev = None
        sum_list = None
 
        # Add the two lists and carry over if necessary
        while first is not None or second is not None or carry == 1:
            new_val = carry
            if first is not None:
                new_val += first.data
            if second is not None:
                new_val += second.data
            carry = new_val // 10
            new_val = new_val % 10
 
            # Create a new node for the sum and append it
            # to the beginning of the final ans list
            new_node = Node(new_val)
            new_node.next = sum_list
            sum_list = new_node
 
            # Initialize nodes for the next iteration
            if first is not None:
                first = first.next
            if second is not None:
                second = second.next
 
        self.print_list(sum_list)
 
    # Utility function to print a linked list
    def print_list(self, head):
        while head.next is not None:
            print(head.data, end=" ")
            head = head.next
        print(head.data)
 
 
# Test the LinkedList class
linked_list = LinkedList()
 
# Create first list
linked_list.head1 = Node(7)
linked_list.head1.next = Node(5)
linked_list.head1.next.next = Node(9)
linked_list.head1.next.next.next = Node(4)
linked_list.head1.next.next.next.next = Node(6)
 
# Create second list
linked_list.head2 = Node(8)
linked_list.head2.next = Node(4)
 
print("Sum is:", end = " ")
# Add the two lists and see the result
linked_list.add_two_lists(linked_list.head1, linked_list.head2)
 
# This code is contributed by lokeshmvs21.

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


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!