Add Numbers Represented by Linked Lists in Java

It is a very interesting problem frequently asked in interviews of top IT companies like Google, Amazon, TCS, Accenture, etc. By solving the problem, one wants to check the logical ability, critical thinking, and problem-solving skill of the interviewee. So, in this section, we are going to solve how to add numbers represented by linked list in Java with different approaches and logic. Also, we will create Java programs for the same.

Problem Statement

Two linked lists are given. Each linked list represents a number. The task is to find the sum of the numbers represented by each linked list. The answer has to be in the form of a linked list. Observe the following examples.

Example 1:

Input:

L1 = 7 -> 9 -> 0 -> 5 -> 9 -> 1 -> 2 -> NULL

L2 = 5 -> 3 -> 8 -> 4 -> 3 -> 6 -> 4 -> NULL

Output: 1 -> 3 -> 2 -> 9 -> 0 -> 2 -> 7 -> 6 -> NULL

Explanation: The number represented by the list L1 is 7905912 and the number represented by the list L2 is 5384364, and their sum is 7905912 + 5384364 = 13290276.

Example 2:

Input:

L1 = 9 -> 8 -> 0 -> 4 -> 3 -> 6 -> 2 -> NULL

L2 = 8 -> 5 -> 7 -> NULL

Output: 9 -> 8 -> 0 -> 5 -> 2 -> 1 -> 9 -> NULL

Explanation: The number represented by the list L1 is 9804362 and the number represented by the list L2 is 857, and their sum is 9804362 + 857 = 9805219.

Solution to the Problem

Approach: Using Recursion

We know that the sum of two numbers can be found by adding digits from right to left. Therefore, it is required to reverse the given linked lists. Though, we will not be literally reversing the linked list. We will imitate the same using recursion. We will do the basic sum that we have learned in our primary classes. After finding the sum, construct a new linked list that shows the sum. Illustration of the same is mentioned below.

FileName: NumberSumLinkedList.java

public class NumberSumLinkedList 
{

// h1 will point to the first node of the first linked list
static LinkedListNode h1;
static LinkedListNode h2;

// class for creating the nodes of the linked list
static class LinkedListNode 
{

int val;
LinkedListNode nxt;

// constructor of the LinkedListNode class
LinkedListNode(int d) 
{
val = d;
nxt = null;
}
}

// The method adds the value of the element of the two linked list f & s
// and displays it
void addTwoLinkedLists(LinkedListNode f, LinkedListNode s) 
{
LinkedListNode begin1 = new LinkedListNode(0);
begin1.nxt = f;
LinkedListNode begin2 = new LinkedListNode(0);
begin2.nxt = s;

addPrecedingZeros(begin1, begin2);
LinkedListNode res = new LinkedListNode(0);
if (addTwoNodes(begin1.nxt, begin2.nxt, res) == 1) 
{
LinkedListNode nde = new LinkedListNode(1);
nde.nxt = res.nxt;
res.nxt = nde;
}
displayLinkedList(res.nxt);
}

// Adds the linked list and returing the carrylists and returning the carry 
private int addTwoNodes(LinkedListNode l1, LinkedListNode l2, LinkedListNode res) 
{
if (l1 == null) 
{
return 0;
}
int num = l1.val + l2.val + addTwoNodes(l1.nxt, l2.nxt, res);
LinkedListNode nde = new LinkedListNode(num % 10);
nde.nxt = res.nxt;
res.nxt = nde;
return num / 10;
}

// Appending the preceding zeros in the case where one list has more nodes as 
//compared to others
private void addPrecedingZeros(LinkedListNode s1, LinkedListNode s2) 
{
LinkedListNode nxt1 = s1.nxt;
LinkedListNode nxt2 = s2.nxt;
while (nxt1 != null && nxt2 != null) 
{
nxt1 = nxt1.nxt;
nxt2 = nxt2.nxt;
}

// first linked has lesser number of elements
// therefore zero will be appended to the first linked list
if (nxt1 == null && nxt2 != null) 
{
while (nxt2 != null) 
{
LinkedListNode nde = new LinkedListNode(0);
nde.nxt = s1.nxt;
s1.nxt = nde;
nxt2 = nxt2.nxt;
}
} 


// second linked has lesser number of elements
// therefore zero will be appended to the second linked list
else if (nxt2 == null && nxt1 != null) 
{
while (nxt1 != null) 
{
LinkedListNode nde = new LinkedListNode(0);
nde.nxt = s2.nxt;
s2.nxt = nde;
nxt1 = nxt1.nxt;
}
}
}

// A method for printing the linked list 
void displayLinkedList(LinkedListNode h) 
{
while (h != null) 
{
System.out.print(h.val + " ");
h = h.nxt;
}
System.out.println(" ");
}

// main method
public static void main(String[] argvs) 
{
// creating an object of the class NumberSumLinkedList
NumberSumLinkedList list = new NumberSumLinkedList();

// creating the first list
list.h1 = new LinkedListNode(7);
list.h1.nxt = new LinkedListNode(9);
list.h1.nxt.nxt = new LinkedListNode(0);
list.h1.nxt.nxt.nxt = new LinkedListNode(5);
list.h1.nxt.nxt.nxt.nxt = new LinkedListNode(9);
list.h1.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(1);
list.h1.nxt.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(2);
System.out.print("First List is ");
list.displayLinkedList(h1);

// creating the second list
list.h2 = new LinkedListNode(5);
list.h2.nxt = new LinkedListNode(3);
list.h2.nxt.nxt = new LinkedListNode(8);
list.h2.nxt.nxt.nxt = new LinkedListNode(4);
list.h2.nxt.nxt.nxt.nxt = new LinkedListNode(3);
list.h2.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(6);
list.h2.nxt.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(4);
System.out.print("Second List is ");
list.displayLinkedList(h2);

System.out.print("Resultant List is ");

// adding the two lists and diplaying the result 
list.addTwoLinkedLists(h1, h2);

System.out.println("\n");


// creating the first list
list.h1 = new LinkedListNode(9);
list.h1.nxt = new LinkedListNode(8);
list.h1.nxt.nxt = new LinkedListNode(0);
list.h1.nxt.nxt.nxt = new LinkedListNode(4);
list.h1.nxt.nxt.nxt.nxt = new LinkedListNode(3);
list.h1.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(6);
list.h1.nxt.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(2);
System.out.print("First List is ");
list.displayLinkedList(h1);

// creating the second list
list.h2 = new LinkedListNode(8);
list.h2.nxt = new LinkedListNode(5);
list.h2.nxt.nxt = new LinkedListNode(7);
System.out.print("Second List is ");
list.displayLinkedList(h2);

System.out.print("Resultant List is ");

// adding the two lists and diplaying the result 
list.addTwoLinkedLists(h1, h2);
}


}

Output:

First List is 7 9 0 5 9 1 2  
Second List is 5 3 8 4 3 6 4  
Resultant List is 1 3 2 9 0 2 7 6  


First List is 9 8 0 4 3 6 2  
Second List is 8 5 7  
Resultant List is 9 8 0 5 2 1 9

Complexity Analysis: Since for the addition, we have to traverse both lists. Therefore, the time complexity of the program is O(a + b), where a is the total number of elements present in the first linked list, and b is the total number of elements present in the second linked list. The space complexity of the program is also O(a + b), as we also need to store the resultant linked list.

Approach: Using Iteration

In this approach, we will be using a stack to store the elements of both linked lists. We know that a stack works in a Last In First Out (LIFO) manner. Therefore, the last node will be popped out first. On the popped elements from both the linked list, we do the add operation.

FileName: MajorityEle1.java

// important import statement 
import java.util.Stack;

public class NumberSumLinkedList1 
{

// h1 will point to the first node of the first linked list
static LinkedListNode h1;
static LinkedListNode h2;

// class for creating the nodes of the linked list
static class LinkedListNode 
{

int val;
LinkedListNode nxt;

// constructor of the LinkedListNode class
LinkedListNode(int d) 
{
val = d;
nxt = null;
}
}

// The method adds the value of the element of the two linked list l1 & l2
// and displays it
void addTwoLinkedLists(LinkedListNode l1, LinkedListNode l2) 
{

// stack for adding elements of the first linked list
Stack<Integer> stk1 = new Stack<Integer>();

// stack for adding elements of the second linked list
Stack<Integer> stk2 = new Stack<Integer>();

// stack for adding elements of the resultant linked list
Stack<Integer> resStack = new Stack<Integer>();

// adding elements of the first linked list to the stack
while(l1 != null)
{
    stk1.push(l1.val);
    l1 = l1.nxt;
}


// adding elements of the second linked list to the stack
while(l2 != null)
{
    stk2.push(l2.val);
    l2 = l2.nxt;
}


// computing sizes of the stacks stk1 and stk2
int s1 = stk1.size();
int s2 = stk2.size();

int carry = 0;

// add the elements of linked list l1 and l2
while(s1 != 0 && s2 != 0)
{
    int a = stk1.pop();
    int b = stk2.pop();
    int dig = (a + b + carry) % 10;
    carry = (a + b + carry) / 10;
    
    // adding elements of the resultant linked list to the stack
    resStack.push(dig);
    s1 = s1 - 1;
    s2 = s2 - 1;
}

// when the size of the first linked list is 
// more than the second linked list
while(s1 != 0)
{
    int a = stk1.pop();
    int dig = (a + carry) % 10;
    carry = (a + carry) / 10;
    resStack.push(dig);
    s1 = s1 - 1;
}


// when the size of the second linked list is 
// more than the first linked list
while(s2 != 0)
{
    int a = stk2.pop();
    int dig = (a + carry) % 10;
    carry = (a + carry) / 10;
    resStack.push(dig);
    s2 = s2 - 1;
    
    System.out.print("vbn ");
}

// if carry is not zero and 
// all the elements of both the linked lists
// are processed, then carry should be pushed 
// in the result stack
if(carry != 0)
{
    resStack.push(carry);
}


// computing the size of the stack resStack
int resStackSize = resStack.size();

LinkedListNode res = new LinkedListNode(0);
LinkedListNode temp = res;

// loop for creating the resultant linked list
// from the resultant stack
while(resStackSize != 0)
{
    temp.nxt = new LinkedListNode(resStack.pop());
    resStackSize = resStackSize - 1;
    temp = temp.nxt;
}

// method for displaying the linked list
displayLinkedList(res.nxt);

}



// A method for printing the linked list 
void displayLinkedList(LinkedListNode h) 
{
while (h != null) 
{
System.out.print(h.val + " ");
h = h.nxt;
}
System.out.println(" ");
}

// main method
public static void main(String[] argvs) 
{
// creating an object of the class NumberSumLinkedList1
NumberSumLinkedList1 list = new NumberSumLinkedList1();

// creating the first list
list.h1 = new LinkedListNode(7);
list.h1.nxt = new LinkedListNode(9);
list.h1.nxt.nxt = new LinkedListNode(0);
list.h1.nxt.nxt.nxt = new LinkedListNode(5);
list.h1.nxt.nxt.nxt.nxt = new LinkedListNode(9);
list.h1.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(1);
list.h1.nxt.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(2);
System.out.print("First List is ");
list.displayLinkedList(h1);

// creating the second list
list.h2 = new LinkedListNode(5);
list.h2.nxt = new LinkedListNode(3);
list.h2.nxt.nxt = new LinkedListNode(8);
list.h2.nxt.nxt.nxt = new LinkedListNode(4);
list.h2.nxt.nxt.nxt.nxt = new LinkedListNode(3);
list.h2.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(6);
list.h2.nxt.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(4);
System.out.print("Second List is ");
list.displayLinkedList(h2);

System.out.print("Resultant List is ");

// adding the two lists and diplaying the result 
list.addTwoLinkedLists(h1, h2);

System.out.println("\n");


// creating the first list
list.h1 = new LinkedListNode(9);
list.h1.nxt = new LinkedListNode(8);
list.h1.nxt.nxt = new LinkedListNode(0);
list.h1.nxt.nxt.nxt = new LinkedListNode(4);
list.h1.nxt.nxt.nxt.nxt = new LinkedListNode(3);
list.h1.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(6);
list.h1.nxt.nxt.nxt.nxt.nxt.nxt = new LinkedListNode(2);
System.out.print("First List is ");
list.displayLinkedList(h1);

// creating the second list
list.h2 = new LinkedListNode(8);
list.h2.nxt = new LinkedListNode(5);
list.h2.nxt.nxt = new LinkedListNode(7);
System.out.print("Second List is ");
list.displayLinkedList(h2);

System.out.print("Resultant List is ");

// adding the two lists and diplaying the result 
list.addTwoLinkedLists(h1, h2);
}


}

Output:

First List is 7 9 0 5 9 1 2  
Second List is 5 3 8 4 3 6 4  
Resultant List is 1 3 2 9 0 2 7 6  


First List is 9 8 0 4 3 6 2  
Second List is 8 5 7  
Resultant List is 9 8 0 5 2 1 9

Complexity Analysis: The time, as well as the space complexity of the program is the same as the above.

Next TopicMajority Element In an Array in Java

← prev next →