Add two numbers represented by linked lists

Linked list

In Computer Science, linked list is a data structure where data is stored in a linear fashion but not stored in the contiguous memory location. There is a series of nodes connected where each node contains the data value and address of the next value.

Problem statement:

Here, we are given two linked lists, and we have to add these two linked lists considering them as two numbers, and return the sum in the form of linked lists.

For example:

We have two linked lists like:

Add two numbers represented by linked lists

In the above example, list1 represents the number 2342, and list2 represents the number 95607. If we sum up these two numbers, we will get the result as 97949, and we will return this number as a linked list.

The most significant digit of any number will be the head of the linked list, and the least significant digit of the number will be the last node of the linked list.

Method 1

The most straightforward approach to solve the problem is that we will convert both lists into equivalent integer values, and we will store the sum of these two numbers into an integer value. Now we will convert this integer into a linked list.

Java Code:

import java.io.*;
import java.util.*;
public class Main{
    public static class Node{
        int value;
        Node next;
        Node(int value){
            this.value=value;
            this.next=null;
        }
    }
    public static class Linked list{
        Node head;
        Node curr;
        Linked list(){
            head=null;
            curr=null;
        }
    }
    public static void main(String[] args){
       Linked list list1=new Linked list();
       Node node=new Node(2);
       list1.head=node;
       list1.curr=list1.head;
       list1.curr.next=new Node(3);
       list1.curr=list1.curr.next;
       list1.curr.next=new Node(4);
       list1.curr=list1.curr.next;
       list1.curr.next=new Node(2);
       list1.curr=list1.curr.next;
       
       Linked list list2=new Linked list();
       Node node2=new Node(9);
       list2.head=node2;
       list2.curr=list2.head;
       list2.curr.next=new Node(5);
       list2.curr=list2.curr.next;
       list2.curr.next=new Node(6);
       list2.curr=list2.curr.next;
       list2.curr.next=new Node(0);
       list2.curr=list2.curr.next;
       list2.curr.next=new Node(7);
       list2.curr=list2.curr.next;
       
       int num1=getNumFromList(list1.head);
       int num2=getNumFromList(list2.head);
       int sum=num1+num2;
    //   System.out.println(num1+" + "+num2+" = "+sum);
      Node newHead=getListFromNum(sum);
      // we will print the resultant Linked list
      Node temp=newHead;
      while(temp!=null){
          System.out.print(temp.value+" ");
          temp=temp.next;
      }
    }
    public static int getNumFromList(Node head){
        // first, we will get the size of the linked list
        int n=0;
        Node temp=head;
        while(temp!=null){
            temp=temp.next;
            n++;
        }
        n--;
        int num=0;
        temp=head;
        while(temp!=null){
           num+= temp.value*Math.pow(10,n--);
           temp=temp.next;
        }
        return num;
    }
    public static Node getListFromNum(int num){
        if(num>=1 && num<=9)
        return new Node(num);
        
        int rem=num/10;
        Node rr=getListFromNum(rem);
        Node temp=new Node(num%10);
        Node temp2=rr;
        while(temp2.next!=null)
        temp2=temp2.next;
        temp2.next=temp;
        return rr;
    }
}

Output:

Explanation

In the above code, we have implemented a custom class for the node and list. With the help of a custom class, we created two linked lists.
Now, we use two functions, one function is to get the integer equivalent of a linked list, and another function is to create the linked list from the given integer.
To get the integer equivalent of a linked list, we first find out the size of the linked list by traversing it. After fitting the number of nodes which will also be the number of digits in the number, we traverse again in the list and add the value to the answer with the appropriate power of 10 according to their index.
After getting the integer equivalent of both numbers, we get the sum and then convert that sum into the list. The second function is returning the head of the Linked list.
In this function, we use the recursive approach to create the list. We created the node for the last digit of the number and called the recursive function for the remaining values. After getting the head node of the remaining values, we added the current node at the end of the list we got from the remaining number.
For the base case, if the number remains a single digit, we will create the node and just return that node.
The time complexity of the above code: would be O(N), where N is the maximum number of elements in both lists.
The space complexity of the above code would be: O(N)

Method 2

We will traverse both lists and add the values during traversal.

In this approach, we will reverse both lists and start adding elements. We will maintain a carry variable which will be propagated in the next iteration again and again. If carry remains 1 in the end, we will create the extra node of that carry. Else, we will not since the resultant linked list will be in the reverse order, so we will reverse it again to get the actual order.

Java code:

import java.io.*;
import java.util.*;
public class Main{
    public static class Node{
        int value;
        Node next;
        Node(int value){
            this.value=value;
            this.next=null;
        }
    }
    public static class Linked list{
        Node head;
        Node curr;
        Linked list(){
            head=null;
            curr=null;
        }
    }
    public static void main(String[] args){
       Linked list list1=new Linked list();
       Node node=new Node(2);
       list1.head=node;
       list1.curr=list1.head;
       list1.curr.next=new Node(3);
       list1.curr=list1.curr.next;
       list1.curr.next=new Node(4);
       list1.curr=list1.curr.next;
       list1.curr.next=new Node(2);
       list1.curr=list1.curr.next;
       
       Linked list list2=new Linked list();
       Node node2=new Node(9);
       list2.head=node2;
       list2.curr=list2.head;
       list2.curr.next=new Node(5);
       list2.curr=list2.curr.next;
       list2.curr.next=new Node(6);
       list2.curr=list2.curr.next;
       list2.curr.next=new Node(0);
       list2.curr=list2.curr.next;
       list2.curr.next=new Node(7);
       list2.curr=list2.curr.next;
       
       Node temp1=reverseList(list1.head);
       Node temp2=reverseList(list2.head);
       int carry=0;
       Linked list result=new Linked list();
      while(temp1!=null || temp2!=null){
          int val=temp1!=null?temp1.value:0;
          val+=temp2!=null?temp2.value:0;
          val+=carry;
            node=new Node(val%10);
          carry=val/10;
          if(result.head==null){
              result.head=node;
              result.curr=node;
          }else{
              result.curr.next=node;
              result.curr=result.curr.next;
          }
          if(temp1!=null)
          temp1=temp1.next;
          if(temp2!=null)
          temp2=temp2.next;
      }
      Node newHead=reverseList(result.head);
      Node temp=newHead;
      while(temp!=null){
          System.out.print(temp.value+" ");
          temp=temp.next;
      }
    }
   
   public static Node reverseList(Node head){
       
       if(head.next==null)
       return head;
       
       Node rr=reverseList(head.next);
       Node temp=rr;
       while(temp.next!=null)
       temp=temp.next;
       temp.next=head;
       head.next=null;
       return rr;
   }
    
}

Time complexity: O(N)

Space complexity: O(N)

Next TopicAdding one to the number represented as array of digits

← prev next →